1 //===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the ASTReader::ReadDeclRecord method, which is the
11 // entrypoint for loading a decl.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/Serialization/ASTReader.h"
18 #include "clang/Sema/IdentifierResolver.h"
19 #include "clang/Sema/Sema.h"
20 #include "clang/Sema/SemaDiagnostic.h"
21 #include "clang/AST/ASTConsumer.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/DeclVisitor.h"
24 #include "clang/AST/DeclGroup.h"
25 #include "clang/AST/DeclCXX.h"
26 #include "clang/AST/DeclTemplate.h"
27 #include "clang/AST/Expr.h"
28 #include "llvm/Support/SaveAndRestore.h"
29 using namespace clang;
30 using namespace clang::serialization;
31
32 //===----------------------------------------------------------------------===//
33 // Declaration deserialization
34 //===----------------------------------------------------------------------===//
35
36 namespace clang {
37 class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
38 ASTReader &Reader;
39 ModuleFile &F;
40 llvm::BitstreamCursor &Cursor;
41 const DeclID ThisDeclID;
42 const unsigned RawLocation;
43 typedef ASTReader::RecordData RecordData;
44 const RecordData &Record;
45 unsigned &Idx;
46 TypeID TypeIDForTypeDecl;
47
48 DeclID DeclContextIDForTemplateParmDecl;
49 DeclID LexicalDeclContextIDForTemplateParmDecl;
50
51 uint64_t GetCurrentCursorOffset();
52
ReadSourceLocation(const RecordData & R,unsigned & I)53 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
54 return Reader.ReadSourceLocation(F, R, I);
55 }
56
ReadSourceRange(const RecordData & R,unsigned & I)57 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
58 return Reader.ReadSourceRange(F, R, I);
59 }
60
GetTypeSourceInfo(const RecordData & R,unsigned & I)61 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
62 return Reader.GetTypeSourceInfo(F, R, I);
63 }
64
ReadDeclID(const RecordData & R,unsigned & I)65 serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
66 return Reader.ReadDeclID(F, R, I);
67 }
68
ReadDecl(const RecordData & R,unsigned & I)69 Decl *ReadDecl(const RecordData &R, unsigned &I) {
70 return Reader.ReadDecl(F, R, I);
71 }
72
73 template<typename T>
ReadDeclAs(const RecordData & R,unsigned & I)74 T *ReadDeclAs(const RecordData &R, unsigned &I) {
75 return Reader.ReadDeclAs<T>(F, R, I);
76 }
77
ReadQualifierInfo(QualifierInfo & Info,const RecordData & R,unsigned & I)78 void ReadQualifierInfo(QualifierInfo &Info,
79 const RecordData &R, unsigned &I) {
80 Reader.ReadQualifierInfo(F, Info, R, I);
81 }
82
ReadDeclarationNameLoc(DeclarationNameLoc & DNLoc,DeclarationName Name,const RecordData & R,unsigned & I)83 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
84 const RecordData &R, unsigned &I) {
85 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
86 }
87
ReadDeclarationNameInfo(DeclarationNameInfo & NameInfo,const RecordData & R,unsigned & I)88 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
89 const RecordData &R, unsigned &I) {
90 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
91 }
92
readSubmoduleID(const RecordData & R,unsigned & I)93 serialization::SubmoduleID readSubmoduleID(const RecordData &R,
94 unsigned &I) {
95 if (I >= R.size())
96 return 0;
97
98 return Reader.getGlobalSubmoduleID(F, R[I++]);
99 }
100
readModule(const RecordData & R,unsigned & I)101 Module *readModule(const RecordData &R, unsigned &I) {
102 return Reader.getSubmodule(readSubmoduleID(R, I));
103 }
104
105 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
106 const RecordData &R, unsigned &I);
107
108 /// \brief RAII class used to capture the first ID within a redeclaration
109 /// chain and to introduce it into the list of pending redeclaration chains
110 /// on destruction.
111 ///
112 /// The caller can choose not to introduce this ID into the redeclaration
113 /// chain by calling \c suppress().
114 class RedeclarableResult {
115 ASTReader &Reader;
116 GlobalDeclID FirstID;
117 mutable bool Owning;
118
119 RedeclarableResult &operator=(RedeclarableResult&); // DO NOT IMPLEMENT
120
121 public:
RedeclarableResult(ASTReader & Reader,GlobalDeclID FirstID)122 RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID)
123 : Reader(Reader), FirstID(FirstID), Owning(true) { }
124
RedeclarableResult(const RedeclarableResult & Other)125 RedeclarableResult(const RedeclarableResult &Other)
126 : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning)
127 {
128 Other.Owning = false;
129 }
130
~RedeclarableResult()131 ~RedeclarableResult() {
132 // FIXME: We want to suppress this when the declaration is local to
133 // a function, since there's no reason to search other AST files
134 // for redeclarations (they can't exist). However, this is hard to
135 // do locally because the declaration hasn't necessarily loaded its
136 // declaration context yet. Also, local externs still have the function
137 // as their (semantic) declaration context, which is wrong and would
138 // break this optimize.
139
140 if (FirstID && Owning && Reader.PendingDeclChainsKnown.insert(FirstID))
141 Reader.PendingDeclChains.push_back(FirstID);
142 }
143
144 /// \brief Retrieve the first ID.
getFirstID() const145 GlobalDeclID getFirstID() const { return FirstID; }
146
147 /// \brief Do not introduce this declaration ID into the set of pending
148 /// declaration chains.
suppress()149 void suppress() {
150 Owning = false;
151 }
152 };
153
154 /// \brief Class used to capture the result of searching for an existing
155 /// declaration of a specific kind and name, along with the ability
156 /// to update the place where this result was found (the declaration
157 /// chain hanging off an identifier or the DeclContext we searched in)
158 /// if requested.
159 class FindExistingResult {
160 ASTReader &Reader;
161 NamedDecl *New;
162 NamedDecl *Existing;
163 mutable bool AddResult;
164
165 FindExistingResult &operator=(FindExistingResult&); // DO NOT IMPLEMENT
166
167 public:
FindExistingResult(ASTReader & Reader)168 FindExistingResult(ASTReader &Reader)
169 : Reader(Reader), New(0), Existing(0), AddResult(false) { }
170
FindExistingResult(ASTReader & Reader,NamedDecl * New,NamedDecl * Existing)171 FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing)
172 : Reader(Reader), New(New), Existing(Existing), AddResult(true) { }
173
FindExistingResult(const FindExistingResult & Other)174 FindExistingResult(const FindExistingResult &Other)
175 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
176 AddResult(Other.AddResult)
177 {
178 Other.AddResult = false;
179 }
180
181 ~FindExistingResult();
182
183 /// \brief Suppress the addition of this result into the known set of
184 /// names.
suppress()185 void suppress() { AddResult = false; }
186
operator NamedDecl*() const187 operator NamedDecl*() const { return Existing; }
188
189 template<typename T>
operator T*() const190 operator T*() const { return dyn_cast_or_null<T>(Existing); }
191 };
192
193 FindExistingResult findExisting(NamedDecl *D);
194
195 public:
ASTDeclReader(ASTReader & Reader,ModuleFile & F,llvm::BitstreamCursor & Cursor,DeclID thisDeclID,unsigned RawLocation,const RecordData & Record,unsigned & Idx)196 ASTDeclReader(ASTReader &Reader, ModuleFile &F,
197 llvm::BitstreamCursor &Cursor, DeclID thisDeclID,
198 unsigned RawLocation,
199 const RecordData &Record, unsigned &Idx)
200 : Reader(Reader), F(F), Cursor(Cursor), ThisDeclID(thisDeclID),
201 RawLocation(RawLocation), Record(Record), Idx(Idx),
202 TypeIDForTypeDecl(0) { }
203
204 static void attachPreviousDecl(Decl *D, Decl *previous);
205 static void attachLatestDecl(Decl *D, Decl *latest);
206
207 void Visit(Decl *D);
208
209 void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
210 const RecordData &Record);
211
setNextObjCCategory(ObjCCategoryDecl * Cat,ObjCCategoryDecl * Next)212 static void setNextObjCCategory(ObjCCategoryDecl *Cat,
213 ObjCCategoryDecl *Next) {
214 Cat->NextClassCategory = Next;
215 }
216
217 void VisitDecl(Decl *D);
218 void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
219 void VisitNamedDecl(NamedDecl *ND);
220 void VisitLabelDecl(LabelDecl *LD);
221 void VisitNamespaceDecl(NamespaceDecl *D);
222 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
223 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
224 void VisitTypeDecl(TypeDecl *TD);
225 void VisitTypedefNameDecl(TypedefNameDecl *TD);
226 void VisitTypedefDecl(TypedefDecl *TD);
227 void VisitTypeAliasDecl(TypeAliasDecl *TD);
228 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
229 void VisitTagDecl(TagDecl *TD);
230 void VisitEnumDecl(EnumDecl *ED);
231 void VisitRecordDecl(RecordDecl *RD);
232 void VisitCXXRecordDecl(CXXRecordDecl *D);
233 void VisitClassTemplateSpecializationDecl(
234 ClassTemplateSpecializationDecl *D);
235 void VisitClassTemplatePartialSpecializationDecl(
236 ClassTemplatePartialSpecializationDecl *D);
237 void VisitClassScopeFunctionSpecializationDecl(
238 ClassScopeFunctionSpecializationDecl *D);
239 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
240 void VisitValueDecl(ValueDecl *VD);
241 void VisitEnumConstantDecl(EnumConstantDecl *ECD);
242 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
243 void VisitDeclaratorDecl(DeclaratorDecl *DD);
244 void VisitFunctionDecl(FunctionDecl *FD);
245 void VisitCXXMethodDecl(CXXMethodDecl *D);
246 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
247 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
248 void VisitCXXConversionDecl(CXXConversionDecl *D);
249 void VisitFieldDecl(FieldDecl *FD);
250 void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
251 void VisitVarDecl(VarDecl *VD);
252 void VisitImplicitParamDecl(ImplicitParamDecl *PD);
253 void VisitParmVarDecl(ParmVarDecl *PD);
254 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
255 void VisitTemplateDecl(TemplateDecl *D);
256 RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
257 void VisitClassTemplateDecl(ClassTemplateDecl *D);
258 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
259 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
260 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
261 void VisitUsingDecl(UsingDecl *D);
262 void VisitUsingShadowDecl(UsingShadowDecl *D);
263 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
264 void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
265 void VisitImportDecl(ImportDecl *D);
266 void VisitAccessSpecDecl(AccessSpecDecl *D);
267 void VisitFriendDecl(FriendDecl *D);
268 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
269 void VisitStaticAssertDecl(StaticAssertDecl *D);
270 void VisitBlockDecl(BlockDecl *BD);
271
272 std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
273
274 template<typename T>
275 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
276
277 template<typename T>
278 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
279
280 // FIXME: Reorder according to DeclNodes.td?
281 void VisitObjCMethodDecl(ObjCMethodDecl *D);
282 void VisitObjCContainerDecl(ObjCContainerDecl *D);
283 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
284 void VisitObjCIvarDecl(ObjCIvarDecl *D);
285 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
286 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
287 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
288 void VisitObjCImplDecl(ObjCImplDecl *D);
289 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
290 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
291 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
292 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
293 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
294 };
295 }
296
GetCurrentCursorOffset()297 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
298 return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
299 }
300
Visit(Decl * D)301 void ASTDeclReader::Visit(Decl *D) {
302 DeclVisitor<ASTDeclReader, void>::Visit(D);
303
304 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
305 if (DD->DeclInfo) {
306 DeclaratorDecl::ExtInfo *Info =
307 DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
308 Info->TInfo =
309 GetTypeSourceInfo(Record, Idx);
310 }
311 else {
312 DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
313 }
314 }
315
316 if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
317 // if we have a fully initialized TypeDecl, we can safely read its type now.
318 TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
319 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
320 // if we have a fully initialized TypeDecl, we can safely read its type now.
321 ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
322 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
323 // FunctionDecl's body was written last after all other Stmts/Exprs.
324 if (Record[Idx++])
325 FD->setLazyBody(GetCurrentCursorOffset());
326 } else if (D->isTemplateParameter()) {
327 // If we have a fully initialized template parameter, we can now
328 // set its DeclContext.
329 DeclContext *SemaDC = cast<DeclContext>(
330 Reader.GetDecl(DeclContextIDForTemplateParmDecl));
331 DeclContext *LexicalDC = cast<DeclContext>(
332 Reader.GetDecl(LexicalDeclContextIDForTemplateParmDecl));
333 D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
334 }
335 }
336
VisitDecl(Decl * D)337 void ASTDeclReader::VisitDecl(Decl *D) {
338 if (D->isTemplateParameter()) {
339 // We don't want to deserialize the DeclContext of a template
340 // parameter immediately, because the template parameter might be
341 // used in the formulation of its DeclContext. Use the translation
342 // unit DeclContext as a placeholder.
343 DeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
344 LexicalDeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
345 D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
346 } else {
347 DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
348 DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
349 // Avoid calling setLexicalDeclContext() directly because it uses
350 // Decl::getASTContext() internally which is unsafe during derialization.
351 D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
352 }
353 D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
354 D->setInvalidDecl(Record[Idx++]);
355 if (Record[Idx++]) { // hasAttrs
356 AttrVec Attrs;
357 Reader.ReadAttributes(F, Attrs, Record, Idx);
358 // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
359 // internally which is unsafe during derialization.
360 D->setAttrsImpl(Attrs, Reader.getContext());
361 }
362 D->setImplicit(Record[Idx++]);
363 D->setUsed(Record[Idx++]);
364 D->setReferenced(Record[Idx++]);
365 D->setTopLevelDeclInObjCContainer(Record[Idx++]);
366 D->setAccess((AccessSpecifier)Record[Idx++]);
367 D->FromASTFile = true;
368 D->setModulePrivate(Record[Idx++]);
369 D->Hidden = D->isModulePrivate();
370
371 // Determine whether this declaration is part of a (sub)module. If so, it
372 // may not yet be visible.
373 if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
374 // Store the owning submodule ID in the declaration.
375 D->setOwningModuleID(SubmoduleID);
376
377 // Module-private declarations are never visible, so there is no work to do.
378 if (!D->isModulePrivate()) {
379 if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
380 if (Owner->NameVisibility != Module::AllVisible) {
381 // The owning module is not visible. Mark this declaration as hidden.
382 D->Hidden = true;
383
384 // Note that this declaration was hidden because its owning module is
385 // not yet visible.
386 Reader.HiddenNamesMap[Owner].push_back(D);
387 }
388 }
389 }
390 }
391 }
392
VisitTranslationUnitDecl(TranslationUnitDecl * TU)393 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
394 llvm_unreachable("Translation units are not serialized");
395 }
396
VisitNamedDecl(NamedDecl * ND)397 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
398 VisitDecl(ND);
399 ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
400 }
401
VisitTypeDecl(TypeDecl * TD)402 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
403 VisitNamedDecl(TD);
404 TD->setLocStart(ReadSourceLocation(Record, Idx));
405 // Delay type reading until after we have fully initialized the decl.
406 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
407 }
408
VisitTypedefNameDecl(TypedefNameDecl * TD)409 void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
410 RedeclarableResult Redecl = VisitRedeclarable(TD);
411 VisitTypeDecl(TD);
412
413 TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
414 mergeRedeclarable(TD, Redecl);
415 }
416
VisitTypedefDecl(TypedefDecl * TD)417 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
418 VisitTypedefNameDecl(TD);
419 }
420
VisitTypeAliasDecl(TypeAliasDecl * TD)421 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
422 VisitTypedefNameDecl(TD);
423 }
424
VisitTagDecl(TagDecl * TD)425 void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
426 RedeclarableResult Redecl = VisitRedeclarable(TD);
427 VisitTypeDecl(TD);
428
429 TD->IdentifierNamespace = Record[Idx++];
430 TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
431 TD->setCompleteDefinition(Record[Idx++]);
432 TD->setEmbeddedInDeclarator(Record[Idx++]);
433 TD->setFreeStanding(Record[Idx++]);
434 TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
435
436 if (Record[Idx++]) { // hasExtInfo
437 TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
438 ReadQualifierInfo(*Info, Record, Idx);
439 TD->TypedefNameDeclOrQualifier = Info;
440 } else
441 TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(Record, Idx));
442
443 mergeRedeclarable(TD, Redecl);
444 }
445
VisitEnumDecl(EnumDecl * ED)446 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
447 VisitTagDecl(ED);
448 if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
449 ED->setIntegerTypeSourceInfo(TI);
450 else
451 ED->setIntegerType(Reader.readType(F, Record, Idx));
452 ED->setPromotionType(Reader.readType(F, Record, Idx));
453 ED->setNumPositiveBits(Record[Idx++]);
454 ED->setNumNegativeBits(Record[Idx++]);
455 ED->IsScoped = Record[Idx++];
456 ED->IsScopedUsingClassTag = Record[Idx++];
457 ED->IsFixed = Record[Idx++];
458
459 if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
460 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
461 SourceLocation POI = ReadSourceLocation(Record, Idx);
462 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
463 ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
464 }
465 }
466
VisitRecordDecl(RecordDecl * RD)467 void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
468 VisitTagDecl(RD);
469 RD->setHasFlexibleArrayMember(Record[Idx++]);
470 RD->setAnonymousStructOrUnion(Record[Idx++]);
471 RD->setHasObjectMember(Record[Idx++]);
472 }
473
VisitValueDecl(ValueDecl * VD)474 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
475 VisitNamedDecl(VD);
476 VD->setType(Reader.readType(F, Record, Idx));
477 }
478
VisitEnumConstantDecl(EnumConstantDecl * ECD)479 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
480 VisitValueDecl(ECD);
481 if (Record[Idx++])
482 ECD->setInitExpr(Reader.ReadExpr(F));
483 ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
484 }
485
VisitDeclaratorDecl(DeclaratorDecl * DD)486 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
487 VisitValueDecl(DD);
488 DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
489 if (Record[Idx++]) { // hasExtInfo
490 DeclaratorDecl::ExtInfo *Info
491 = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
492 ReadQualifierInfo(*Info, Record, Idx);
493 DD->DeclInfo = Info;
494 }
495 }
496
VisitFunctionDecl(FunctionDecl * FD)497 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
498 RedeclarableResult Redecl = VisitRedeclarable(FD);
499 VisitDeclaratorDecl(FD);
500
501 ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
502 FD->IdentifierNamespace = Record[Idx++];
503
504 // FunctionDecl's body is handled last at ASTDeclReader::Visit,
505 // after everything else is read.
506
507 FD->SClass = (StorageClass)Record[Idx++];
508 FD->SClassAsWritten = (StorageClass)Record[Idx++];
509 FD->IsInline = Record[Idx++];
510 FD->IsInlineSpecified = Record[Idx++];
511 FD->IsVirtualAsWritten = Record[Idx++];
512 FD->IsPure = Record[Idx++];
513 FD->HasInheritedPrototype = Record[Idx++];
514 FD->HasWrittenPrototype = Record[Idx++];
515 FD->IsDeleted = Record[Idx++];
516 FD->IsTrivial = Record[Idx++];
517 FD->IsDefaulted = Record[Idx++];
518 FD->IsExplicitlyDefaulted = Record[Idx++];
519 FD->HasImplicitReturnZero = Record[Idx++];
520 FD->IsConstexpr = Record[Idx++];
521 FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
522
523 switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
524 case FunctionDecl::TK_NonTemplate:
525 mergeRedeclarable(FD, Redecl);
526 break;
527 case FunctionDecl::TK_FunctionTemplate:
528 FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
529 Idx));
530 break;
531 case FunctionDecl::TK_MemberSpecialization: {
532 FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
533 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
534 SourceLocation POI = ReadSourceLocation(Record, Idx);
535 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
536 FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
537 break;
538 }
539 case FunctionDecl::TK_FunctionTemplateSpecialization: {
540 FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
541 Idx);
542 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
543
544 // Template arguments.
545 SmallVector<TemplateArgument, 8> TemplArgs;
546 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
547
548 // Template args as written.
549 SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
550 SourceLocation LAngleLoc, RAngleLoc;
551 bool HasTemplateArgumentsAsWritten = Record[Idx++];
552 if (HasTemplateArgumentsAsWritten) {
553 unsigned NumTemplateArgLocs = Record[Idx++];
554 TemplArgLocs.reserve(NumTemplateArgLocs);
555 for (unsigned i=0; i != NumTemplateArgLocs; ++i)
556 TemplArgLocs.push_back(
557 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
558
559 LAngleLoc = ReadSourceLocation(Record, Idx);
560 RAngleLoc = ReadSourceLocation(Record, Idx);
561 }
562
563 SourceLocation POI = ReadSourceLocation(Record, Idx);
564
565 ASTContext &C = Reader.getContext();
566 TemplateArgumentList *TemplArgList
567 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
568 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
569 for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
570 TemplArgsInfo.addArgument(TemplArgLocs[i]);
571 FunctionTemplateSpecializationInfo *FTInfo
572 = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
573 TemplArgList,
574 HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0,
575 POI);
576 FD->TemplateOrSpecialization = FTInfo;
577
578 if (FD->isCanonicalDecl()) { // if canonical add to template's set.
579 // The template that contains the specializations set. It's not safe to
580 // use getCanonicalDecl on Template since it may still be initializing.
581 FunctionTemplateDecl *CanonTemplate
582 = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
583 // Get the InsertPos by FindNodeOrInsertPos() instead of calling
584 // InsertNode(FTInfo) directly to avoid the getASTContext() call in
585 // FunctionTemplateSpecializationInfo's Profile().
586 // We avoid getASTContext because a decl in the parent hierarchy may
587 // be initializing.
588 llvm::FoldingSetNodeID ID;
589 FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
590 TemplArgs.size(), C);
591 void *InsertPos = 0;
592 CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
593 assert(InsertPos && "Another specialization already inserted!");
594 CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
595 }
596 break;
597 }
598 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
599 // Templates.
600 UnresolvedSet<8> TemplDecls;
601 unsigned NumTemplates = Record[Idx++];
602 while (NumTemplates--)
603 TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
604
605 // Templates args.
606 TemplateArgumentListInfo TemplArgs;
607 unsigned NumArgs = Record[Idx++];
608 while (NumArgs--)
609 TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
610 TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
611 TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
612
613 FD->setDependentTemplateSpecialization(Reader.getContext(),
614 TemplDecls, TemplArgs);
615 break;
616 }
617 }
618
619 // Read in the parameters.
620 unsigned NumParams = Record[Idx++];
621 SmallVector<ParmVarDecl *, 16> Params;
622 Params.reserve(NumParams);
623 for (unsigned I = 0; I != NumParams; ++I)
624 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
625 FD->setParams(Reader.getContext(), Params);
626 }
627
VisitObjCMethodDecl(ObjCMethodDecl * MD)628 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
629 VisitNamedDecl(MD);
630 if (Record[Idx++]) {
631 // In practice, this won't be executed (since method definitions
632 // don't occur in header files).
633 // Switch case IDs for this method body.
634 ASTReader::SwitchCaseMapTy SwitchCaseStmtsForObjCMethod;
635 SaveAndRestore<ASTReader::SwitchCaseMapTy *>
636 SCFOM(Reader.CurrSwitchCaseStmts, &SwitchCaseStmtsForObjCMethod);
637 MD->setBody(Reader.ReadStmt(F));
638 MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
639 MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
640 }
641 MD->setInstanceMethod(Record[Idx++]);
642 MD->setVariadic(Record[Idx++]);
643 MD->setSynthesized(Record[Idx++]);
644 MD->setDefined(Record[Idx++]);
645 MD->IsOverriding = Record[Idx++];
646
647 MD->IsRedeclaration = Record[Idx++];
648 MD->HasRedeclaration = Record[Idx++];
649 if (MD->HasRedeclaration)
650 Reader.getContext().setObjCMethodRedeclaration(MD,
651 ReadDeclAs<ObjCMethodDecl>(Record, Idx));
652
653 MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
654 MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
655 MD->SetRelatedResultType(Record[Idx++]);
656 MD->setResultType(Reader.readType(F, Record, Idx));
657 MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
658 MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
659 unsigned NumParams = Record[Idx++];
660 SmallVector<ParmVarDecl *, 16> Params;
661 Params.reserve(NumParams);
662 for (unsigned I = 0; I != NumParams; ++I)
663 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
664
665 MD->SelLocsKind = Record[Idx++];
666 unsigned NumStoredSelLocs = Record[Idx++];
667 SmallVector<SourceLocation, 16> SelLocs;
668 SelLocs.reserve(NumStoredSelLocs);
669 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
670 SelLocs.push_back(ReadSourceLocation(Record, Idx));
671
672 MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
673 }
674
VisitObjCContainerDecl(ObjCContainerDecl * CD)675 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
676 VisitNamedDecl(CD);
677 CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
678 CD->setAtEndRange(ReadSourceRange(Record, Idx));
679 }
680
VisitObjCInterfaceDecl(ObjCInterfaceDecl * ID)681 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
682 RedeclarableResult Redecl = VisitRedeclarable(ID);
683 VisitObjCContainerDecl(ID);
684 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
685 mergeRedeclarable(ID, Redecl);
686
687 if (Record[Idx++]) {
688 // Read the definition.
689 ID->allocateDefinitionData();
690
691 // Set the definition data of the canonical declaration, so other
692 // redeclarations will see it.
693 ID->getCanonicalDecl()->Data = ID->Data;
694
695 ObjCInterfaceDecl::DefinitionData &Data = ID->data();
696
697 // Read the superclass.
698 Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
699 Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
700
701 Data.EndLoc = ReadSourceLocation(Record, Idx);
702
703 // Read the directly referenced protocols and their SourceLocations.
704 unsigned NumProtocols = Record[Idx++];
705 SmallVector<ObjCProtocolDecl *, 16> Protocols;
706 Protocols.reserve(NumProtocols);
707 for (unsigned I = 0; I != NumProtocols; ++I)
708 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
709 SmallVector<SourceLocation, 16> ProtoLocs;
710 ProtoLocs.reserve(NumProtocols);
711 for (unsigned I = 0; I != NumProtocols; ++I)
712 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
713 ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
714 Reader.getContext());
715
716 // Read the transitive closure of protocols referenced by this class.
717 NumProtocols = Record[Idx++];
718 Protocols.clear();
719 Protocols.reserve(NumProtocols);
720 for (unsigned I = 0; I != NumProtocols; ++I)
721 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
722 ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
723 Reader.getContext());
724
725 // We will rebuild this list lazily.
726 ID->setIvarList(0);
727
728 // Note that we have deserialized a definition.
729 Reader.PendingDefinitions.insert(ID);
730
731 // Note that we've loaded this Objective-C class.
732 Reader.ObjCClassesLoaded.push_back(ID);
733 } else {
734 ID->Data = ID->getCanonicalDecl()->Data;
735 }
736 }
737
VisitObjCIvarDecl(ObjCIvarDecl * IVD)738 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
739 VisitFieldDecl(IVD);
740 IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
741 // This field will be built lazily.
742 IVD->setNextIvar(0);
743 bool synth = Record[Idx++];
744 IVD->setSynthesize(synth);
745 }
746
VisitObjCProtocolDecl(ObjCProtocolDecl * PD)747 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
748 RedeclarableResult Redecl = VisitRedeclarable(PD);
749 VisitObjCContainerDecl(PD);
750 mergeRedeclarable(PD, Redecl);
751
752 if (Record[Idx++]) {
753 // Read the definition.
754 PD->allocateDefinitionData();
755
756 // Set the definition data of the canonical declaration, so other
757 // redeclarations will see it.
758 PD->getCanonicalDecl()->Data = PD->Data;
759
760 unsigned NumProtoRefs = Record[Idx++];
761 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
762 ProtoRefs.reserve(NumProtoRefs);
763 for (unsigned I = 0; I != NumProtoRefs; ++I)
764 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
765 SmallVector<SourceLocation, 16> ProtoLocs;
766 ProtoLocs.reserve(NumProtoRefs);
767 for (unsigned I = 0; I != NumProtoRefs; ++I)
768 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
769 PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
770 Reader.getContext());
771
772 // Note that we have deserialized a definition.
773 Reader.PendingDefinitions.insert(PD);
774 } else {
775 PD->Data = PD->getCanonicalDecl()->Data;
776 }
777 }
778
VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl * FD)779 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
780 VisitFieldDecl(FD);
781 }
782
VisitObjCCategoryDecl(ObjCCategoryDecl * CD)783 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
784 VisitObjCContainerDecl(CD);
785 CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
786 CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
787 CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
788
789 // Note that this category has been deserialized. We do this before
790 // deserializing the interface declaration, so that it will consider this
791 /// category.
792 Reader.CategoriesDeserialized.insert(CD);
793
794 CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
795 unsigned NumProtoRefs = Record[Idx++];
796 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
797 ProtoRefs.reserve(NumProtoRefs);
798 for (unsigned I = 0; I != NumProtoRefs; ++I)
799 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
800 SmallVector<SourceLocation, 16> ProtoLocs;
801 ProtoLocs.reserve(NumProtoRefs);
802 for (unsigned I = 0; I != NumProtoRefs; ++I)
803 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
804 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
805 Reader.getContext());
806 }
807
VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl * CAD)808 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
809 VisitNamedDecl(CAD);
810 CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
811 }
812
VisitObjCPropertyDecl(ObjCPropertyDecl * D)813 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
814 VisitNamedDecl(D);
815 D->setAtLoc(ReadSourceLocation(Record, Idx));
816 D->setLParenLoc(ReadSourceLocation(Record, Idx));
817 D->setType(GetTypeSourceInfo(Record, Idx));
818 // FIXME: stable encoding
819 D->setPropertyAttributes(
820 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
821 D->setPropertyAttributesAsWritten(
822 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
823 // FIXME: stable encoding
824 D->setPropertyImplementation(
825 (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
826 D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
827 D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
828 D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
829 D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
830 D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
831 }
832
VisitObjCImplDecl(ObjCImplDecl * D)833 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
834 VisitObjCContainerDecl(D);
835 D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
836 }
837
VisitObjCCategoryImplDecl(ObjCCategoryImplDecl * D)838 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
839 VisitObjCImplDecl(D);
840 D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
841 D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
842 }
843
VisitObjCImplementationDecl(ObjCImplementationDecl * D)844 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
845 VisitObjCImplDecl(D);
846 D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
847 D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
848 D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
849 llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
850 = Reader.ReadCXXCtorInitializers(F, Record, Idx);
851 }
852
853
VisitObjCPropertyImplDecl(ObjCPropertyImplDecl * D)854 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
855 VisitDecl(D);
856 D->setAtLoc(ReadSourceLocation(Record, Idx));
857 D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
858 D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
859 D->IvarLoc = ReadSourceLocation(Record, Idx);
860 D->setGetterCXXConstructor(Reader.ReadExpr(F));
861 D->setSetterCXXAssignment(Reader.ReadExpr(F));
862 }
863
VisitFieldDecl(FieldDecl * FD)864 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
865 VisitDeclaratorDecl(FD);
866 FD->Mutable = Record[Idx++];
867 if (int BitWidthOrInitializer = Record[Idx++]) {
868 FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1);
869 FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F));
870 }
871 if (!FD->getDeclName()) {
872 if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
873 Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
874 }
875 }
876
VisitIndirectFieldDecl(IndirectFieldDecl * FD)877 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
878 VisitValueDecl(FD);
879
880 FD->ChainingSize = Record[Idx++];
881 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
882 FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
883
884 for (unsigned I = 0; I != FD->ChainingSize; ++I)
885 FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
886 }
887
VisitVarDecl(VarDecl * VD)888 void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
889 RedeclarableResult Redecl = VisitRedeclarable(VD);
890 VisitDeclaratorDecl(VD);
891
892 VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
893 VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
894 VD->VarDeclBits.ThreadSpecified = Record[Idx++];
895 VD->VarDeclBits.InitStyle = Record[Idx++];
896 VD->VarDeclBits.ExceptionVar = Record[Idx++];
897 VD->VarDeclBits.NRVOVariable = Record[Idx++];
898 VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
899 VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
900
901 // Only true variables (not parameters or implicit parameters) can be merged.
902 if (VD->getKind() == Decl::Var)
903 mergeRedeclarable(VD, Redecl);
904
905 if (uint64_t Val = Record[Idx++]) {
906 VD->setInit(Reader.ReadExpr(F));
907 if (Val > 1) {
908 EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
909 Eval->CheckedICE = true;
910 Eval->IsICE = Val == 3;
911 }
912 }
913
914 if (Record[Idx++]) { // HasMemberSpecializationInfo.
915 VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
916 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
917 SourceLocation POI = ReadSourceLocation(Record, Idx);
918 Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
919 }
920 }
921
VisitImplicitParamDecl(ImplicitParamDecl * PD)922 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
923 VisitVarDecl(PD);
924 }
925
VisitParmVarDecl(ParmVarDecl * PD)926 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
927 VisitVarDecl(PD);
928 unsigned isObjCMethodParam = Record[Idx++];
929 unsigned scopeDepth = Record[Idx++];
930 unsigned scopeIndex = Record[Idx++];
931 unsigned declQualifier = Record[Idx++];
932 if (isObjCMethodParam) {
933 assert(scopeDepth == 0);
934 PD->setObjCMethodScopeInfo(scopeIndex);
935 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
936 } else {
937 PD->setScopeInfo(scopeDepth, scopeIndex);
938 }
939 PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
940 PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
941 if (Record[Idx++]) // hasUninstantiatedDefaultArg.
942 PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
943 }
944
VisitFileScopeAsmDecl(FileScopeAsmDecl * AD)945 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
946 VisitDecl(AD);
947 AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
948 AD->setRParenLoc(ReadSourceLocation(Record, Idx));
949 }
950
VisitBlockDecl(BlockDecl * BD)951 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
952 VisitDecl(BD);
953 BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
954 BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
955 unsigned NumParams = Record[Idx++];
956 SmallVector<ParmVarDecl *, 16> Params;
957 Params.reserve(NumParams);
958 for (unsigned I = 0; I != NumParams; ++I)
959 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
960 BD->setParams(Params);
961
962 BD->setIsVariadic(Record[Idx++]);
963 BD->setBlockMissingReturnType(Record[Idx++]);
964 BD->setIsConversionFromLambda(Record[Idx++]);
965
966 bool capturesCXXThis = Record[Idx++];
967 unsigned numCaptures = Record[Idx++];
968 SmallVector<BlockDecl::Capture, 16> captures;
969 captures.reserve(numCaptures);
970 for (unsigned i = 0; i != numCaptures; ++i) {
971 VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
972 unsigned flags = Record[Idx++];
973 bool byRef = (flags & 1);
974 bool nested = (flags & 2);
975 Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0);
976
977 captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
978 }
979 BD->setCaptures(Reader.getContext(), captures.begin(),
980 captures.end(), capturesCXXThis);
981 }
982
VisitLinkageSpecDecl(LinkageSpecDecl * D)983 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
984 VisitDecl(D);
985 D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
986 D->setExternLoc(ReadSourceLocation(Record, Idx));
987 D->setRBraceLoc(ReadSourceLocation(Record, Idx));
988 }
989
VisitLabelDecl(LabelDecl * D)990 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
991 VisitNamedDecl(D);
992 D->setLocStart(ReadSourceLocation(Record, Idx));
993 }
994
995
VisitNamespaceDecl(NamespaceDecl * D)996 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
997 RedeclarableResult Redecl = VisitRedeclarable(D);
998 VisitNamedDecl(D);
999 D->setInline(Record[Idx++]);
1000 D->LocStart = ReadSourceLocation(Record, Idx);
1001 D->RBraceLoc = ReadSourceLocation(Record, Idx);
1002 mergeRedeclarable(D, Redecl);
1003
1004 if (Redecl.getFirstID() == ThisDeclID) {
1005 // Each module has its own anonymous namespace, which is disjoint from
1006 // any other module's anonymous namespaces, so don't attach the anonymous
1007 // namespace at all.
1008 NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1009 if (F.Kind != MK_Module)
1010 D->setAnonymousNamespace(Anon);
1011 } else {
1012 // Link this namespace back to the first declaration, which has already
1013 // been deserialized.
1014 D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDeclaration());
1015 }
1016 }
1017
VisitNamespaceAliasDecl(NamespaceAliasDecl * D)1018 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1019 VisitNamedDecl(D);
1020 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1021 D->IdentLoc = ReadSourceLocation(Record, Idx);
1022 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1023 D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1024 }
1025
VisitUsingDecl(UsingDecl * D)1026 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1027 VisitNamedDecl(D);
1028 D->setUsingLocation(ReadSourceLocation(Record, Idx));
1029 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1030 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1031 D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1032 D->setTypeName(Record[Idx++]);
1033 if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1034 Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1035 }
1036
VisitUsingShadowDecl(UsingShadowDecl * D)1037 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1038 VisitNamedDecl(D);
1039 D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1040 D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1041 UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1042 if (Pattern)
1043 Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1044 }
1045
VisitUsingDirectiveDecl(UsingDirectiveDecl * D)1046 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1047 VisitNamedDecl(D);
1048 D->UsingLoc = ReadSourceLocation(Record, Idx);
1049 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1050 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1051 D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1052 D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1053 }
1054
VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl * D)1055 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1056 VisitValueDecl(D);
1057 D->setUsingLoc(ReadSourceLocation(Record, Idx));
1058 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1059 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1060 }
1061
VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl * D)1062 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1063 UnresolvedUsingTypenameDecl *D) {
1064 VisitTypeDecl(D);
1065 D->TypenameLocation = ReadSourceLocation(Record, Idx);
1066 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1067 }
1068
ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData & Data,const RecordData & Record,unsigned & Idx)1069 void ASTDeclReader::ReadCXXDefinitionData(
1070 struct CXXRecordDecl::DefinitionData &Data,
1071 const RecordData &Record, unsigned &Idx) {
1072 // Note: the caller has deserialized the IsLambda bit already.
1073 Data.UserDeclaredConstructor = Record[Idx++];
1074 Data.UserDeclaredCopyConstructor = Record[Idx++];
1075 Data.UserDeclaredMoveConstructor = Record[Idx++];
1076 Data.UserDeclaredCopyAssignment = Record[Idx++];
1077 Data.UserDeclaredMoveAssignment = Record[Idx++];
1078 Data.UserDeclaredDestructor = Record[Idx++];
1079 Data.Aggregate = Record[Idx++];
1080 Data.PlainOldData = Record[Idx++];
1081 Data.Empty = Record[Idx++];
1082 Data.Polymorphic = Record[Idx++];
1083 Data.Abstract = Record[Idx++];
1084 Data.IsStandardLayout = Record[Idx++];
1085 Data.HasNoNonEmptyBases = Record[Idx++];
1086 Data.HasPrivateFields = Record[Idx++];
1087 Data.HasProtectedFields = Record[Idx++];
1088 Data.HasPublicFields = Record[Idx++];
1089 Data.HasMutableFields = Record[Idx++];
1090 Data.HasOnlyCMembers = Record[Idx++];
1091 Data.HasInClassInitializer = Record[Idx++];
1092 Data.HasTrivialDefaultConstructor = Record[Idx++];
1093 Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1094 Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1095 Data.HasConstexprDefaultConstructor = Record[Idx++];
1096 Data.HasTrivialCopyConstructor = Record[Idx++];
1097 Data.HasTrivialMoveConstructor = Record[Idx++];
1098 Data.HasTrivialCopyAssignment = Record[Idx++];
1099 Data.HasTrivialMoveAssignment = Record[Idx++];
1100 Data.HasTrivialDestructor = Record[Idx++];
1101 Data.HasIrrelevantDestructor = Record[Idx++];
1102 Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1103 Data.ComputedVisibleConversions = Record[Idx++];
1104 Data.UserProvidedDefaultConstructor = Record[Idx++];
1105 Data.DeclaredDefaultConstructor = Record[Idx++];
1106 Data.DeclaredCopyConstructor = Record[Idx++];
1107 Data.DeclaredMoveConstructor = Record[Idx++];
1108 Data.DeclaredCopyAssignment = Record[Idx++];
1109 Data.DeclaredMoveAssignment = Record[Idx++];
1110 Data.DeclaredDestructor = Record[Idx++];
1111 Data.FailedImplicitMoveConstructor = Record[Idx++];
1112 Data.FailedImplicitMoveAssignment = Record[Idx++];
1113
1114 Data.NumBases = Record[Idx++];
1115 if (Data.NumBases)
1116 Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1117 Data.NumVBases = Record[Idx++];
1118 if (Data.NumVBases)
1119 Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1120
1121 Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1122 Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1123 assert(Data.Definition && "Data.Definition should be already set!");
1124 Data.FirstFriend = ReadDeclAs<FriendDecl>(Record, Idx);
1125
1126 if (Data.IsLambda) {
1127 typedef LambdaExpr::Capture Capture;
1128 CXXRecordDecl::LambdaDefinitionData &Lambda
1129 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1130 Lambda.Dependent = Record[Idx++];
1131 Lambda.NumCaptures = Record[Idx++];
1132 Lambda.NumExplicitCaptures = Record[Idx++];
1133 Lambda.ManglingNumber = Record[Idx++];
1134 Lambda.ContextDecl = ReadDecl(Record, Idx);
1135 Lambda.Captures
1136 = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1137 Capture *ToCapture = Lambda.Captures;
1138 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1139 SourceLocation Loc = ReadSourceLocation(Record, Idx);
1140 bool IsImplicit = Record[Idx++];
1141 LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1142 VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1143 SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1144 *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1145 }
1146 }
1147 }
1148
VisitCXXRecordDecl(CXXRecordDecl * D)1149 void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
1150 VisitRecordDecl(D);
1151
1152 ASTContext &C = Reader.getContext();
1153 if (Record[Idx++]) {
1154 // Determine whether this is a lambda closure type, so that we can
1155 // allocate the appropriate DefinitionData structure.
1156 bool IsLambda = Record[Idx++];
1157 if (IsLambda)
1158 D->DefinitionData = new (C) CXXRecordDecl::LambdaDefinitionData(D, false);
1159 else
1160 D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
1161
1162 // Propagate the DefinitionData pointer to the canonical declaration, so
1163 // that all other deserialized declarations will see it.
1164 // FIXME: Complain if there already is a DefinitionData!
1165 D->getCanonicalDecl()->DefinitionData = D->DefinitionData;
1166
1167 ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
1168
1169 // Note that we have deserialized a definition. Any declarations
1170 // deserialized before this one will be be given the DefinitionData pointer
1171 // at the end.
1172 Reader.PendingDefinitions.insert(D);
1173 } else {
1174 // Propagate DefinitionData pointer from the canonical declaration.
1175 D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1176 }
1177
1178 enum CXXRecKind {
1179 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1180 };
1181 switch ((CXXRecKind)Record[Idx++]) {
1182 case CXXRecNotTemplate:
1183 break;
1184 case CXXRecTemplate:
1185 D->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1186 break;
1187 case CXXRecMemberSpecialization: {
1188 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1189 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1190 SourceLocation POI = ReadSourceLocation(Record, Idx);
1191 MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1192 MSI->setPointOfInstantiation(POI);
1193 D->TemplateOrInstantiation = MSI;
1194 break;
1195 }
1196 }
1197
1198 // Load the key function to avoid deserializing every method so we can
1199 // compute it.
1200 if (D->IsCompleteDefinition) {
1201 if (CXXMethodDecl *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1202 C.KeyFunctions[D] = Key;
1203 }
1204 }
1205
VisitCXXMethodDecl(CXXMethodDecl * D)1206 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1207 VisitFunctionDecl(D);
1208 unsigned NumOverridenMethods = Record[Idx++];
1209 while (NumOverridenMethods--) {
1210 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1211 // MD may be initializing.
1212 if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1213 Reader.getContext().addOverriddenMethod(D, MD);
1214 }
1215 }
1216
VisitCXXConstructorDecl(CXXConstructorDecl * D)1217 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1218 VisitCXXMethodDecl(D);
1219
1220 D->IsExplicitSpecified = Record[Idx++];
1221 D->ImplicitlyDefined = Record[Idx++];
1222 llvm::tie(D->CtorInitializers, D->NumCtorInitializers)
1223 = Reader.ReadCXXCtorInitializers(F, Record, Idx);
1224 }
1225
VisitCXXDestructorDecl(CXXDestructorDecl * D)1226 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1227 VisitCXXMethodDecl(D);
1228
1229 D->ImplicitlyDefined = Record[Idx++];
1230 D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1231 }
1232
VisitCXXConversionDecl(CXXConversionDecl * D)1233 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1234 VisitCXXMethodDecl(D);
1235 D->IsExplicitSpecified = Record[Idx++];
1236 }
1237
VisitImportDecl(ImportDecl * D)1238 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1239 VisitDecl(D);
1240 D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1241 D->ImportedAndComplete.setInt(Record[Idx++]);
1242 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1243 for (unsigned I = 0, N = Record.back(); I != N; ++I)
1244 StoredLocs[I] = ReadSourceLocation(Record, Idx);
1245 }
1246
VisitAccessSpecDecl(AccessSpecDecl * D)1247 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1248 VisitDecl(D);
1249 D->setColonLoc(ReadSourceLocation(Record, Idx));
1250 }
1251
VisitFriendDecl(FriendDecl * D)1252 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1253 VisitDecl(D);
1254 if (Record[Idx++])
1255 D->Friend = GetTypeSourceInfo(Record, Idx);
1256 else
1257 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1258 D->NextFriend = Record[Idx++];
1259 D->UnsupportedFriend = (Record[Idx++] != 0);
1260 D->FriendLoc = ReadSourceLocation(Record, Idx);
1261 }
1262
VisitFriendTemplateDecl(FriendTemplateDecl * D)1263 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1264 VisitDecl(D);
1265 unsigned NumParams = Record[Idx++];
1266 D->NumParams = NumParams;
1267 D->Params = new TemplateParameterList*[NumParams];
1268 for (unsigned i = 0; i != NumParams; ++i)
1269 D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1270 if (Record[Idx++]) // HasFriendDecl
1271 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1272 else
1273 D->Friend = GetTypeSourceInfo(Record, Idx);
1274 D->FriendLoc = ReadSourceLocation(Record, Idx);
1275 }
1276
VisitTemplateDecl(TemplateDecl * D)1277 void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1278 VisitNamedDecl(D);
1279
1280 NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx);
1281 TemplateParameterList* TemplateParams
1282 = Reader.ReadTemplateParameterList(F, Record, Idx);
1283 D->init(TemplatedDecl, TemplateParams);
1284 }
1285
1286 ASTDeclReader::RedeclarableResult
VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl * D)1287 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1288 RedeclarableResult Redecl = VisitRedeclarable(D);
1289
1290 // Make sure we've allocated the Common pointer first. We do this before
1291 // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1292 RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1293 if (!CanonD->Common) {
1294 CanonD->Common = CanonD->newCommon(Reader.getContext());
1295 Reader.PendingDefinitions.insert(CanonD);
1296 }
1297 D->Common = CanonD->Common;
1298
1299 // If this is the first declaration of the template, fill in the information
1300 // for the 'common' pointer.
1301 if (ThisDeclID == Redecl.getFirstID()) {
1302 if (RedeclarableTemplateDecl *RTD
1303 = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1304 assert(RTD->getKind() == D->getKind() &&
1305 "InstantiatedFromMemberTemplate kind mismatch");
1306 D->setInstantiatedFromMemberTemplate(RTD);
1307 if (Record[Idx++])
1308 D->setMemberSpecialization();
1309 }
1310 }
1311
1312 VisitTemplateDecl(D);
1313 D->IdentifierNamespace = Record[Idx++];
1314
1315 return Redecl;
1316 }
1317
VisitClassTemplateDecl(ClassTemplateDecl * D)1318 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1319 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1320
1321 if (ThisDeclID == Redecl.getFirstID()) {
1322 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1323 // the specializations.
1324 SmallVector<serialization::DeclID, 2> SpecIDs;
1325 SpecIDs.push_back(0);
1326
1327 // Specializations.
1328 unsigned Size = Record[Idx++];
1329 SpecIDs[0] += Size;
1330 for (unsigned I = 0; I != Size; ++I)
1331 SpecIDs.push_back(ReadDeclID(Record, Idx));
1332
1333 // Partial specializations.
1334 Size = Record[Idx++];
1335 SpecIDs[0] += Size;
1336 for (unsigned I = 0; I != Size; ++I)
1337 SpecIDs.push_back(ReadDeclID(Record, Idx));
1338
1339 if (SpecIDs[0]) {
1340 typedef serialization::DeclID DeclID;
1341
1342 ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1343 // FIXME: Append specializations!
1344 CommonPtr->LazySpecializations
1345 = new (Reader.getContext()) DeclID [SpecIDs.size()];
1346 memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1347 SpecIDs.size() * sizeof(DeclID));
1348 }
1349
1350 // InjectedClassNameType is computed.
1351 }
1352 }
1353
VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl * D)1354 void ASTDeclReader::VisitClassTemplateSpecializationDecl(
1355 ClassTemplateSpecializationDecl *D) {
1356 VisitCXXRecordDecl(D);
1357
1358 ASTContext &C = Reader.getContext();
1359 if (Decl *InstD = ReadDecl(Record, Idx)) {
1360 if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1361 D->SpecializedTemplate = CTD;
1362 } else {
1363 SmallVector<TemplateArgument, 8> TemplArgs;
1364 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1365 TemplateArgumentList *ArgList
1366 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1367 TemplArgs.size());
1368 ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1369 = new (C) ClassTemplateSpecializationDecl::
1370 SpecializedPartialSpecialization();
1371 PS->PartialSpecialization
1372 = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1373 PS->TemplateArgs = ArgList;
1374 D->SpecializedTemplate = PS;
1375 }
1376 }
1377
1378 // Explicit info.
1379 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1380 ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1381 = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1382 ExplicitInfo->TypeAsWritten = TyInfo;
1383 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1384 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1385 D->ExplicitInfo = ExplicitInfo;
1386 }
1387
1388 SmallVector<TemplateArgument, 8> TemplArgs;
1389 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1390 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1391 TemplArgs.size());
1392 D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1393 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1394
1395 if (D->isCanonicalDecl()) { // It's kept in the folding set.
1396 ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1397 if (ClassTemplatePartialSpecializationDecl *Partial
1398 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1399 CanonPattern->getCommonPtr()->PartialSpecializations.InsertNode(Partial);
1400 } else {
1401 CanonPattern->getCommonPtr()->Specializations.InsertNode(D);
1402 }
1403 }
1404 }
1405
VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl * D)1406 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1407 ClassTemplatePartialSpecializationDecl *D) {
1408 VisitClassTemplateSpecializationDecl(D);
1409
1410 ASTContext &C = Reader.getContext();
1411 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1412
1413 unsigned NumArgs = Record[Idx++];
1414 if (NumArgs) {
1415 D->NumArgsAsWritten = NumArgs;
1416 D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
1417 for (unsigned i=0; i != NumArgs; ++i)
1418 D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1419 }
1420
1421 D->SequenceNumber = Record[Idx++];
1422
1423 // These are read/set from/to the first declaration.
1424 if (D->getPreviousDecl() == 0) {
1425 D->InstantiatedFromMember.setPointer(
1426 ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1427 D->InstantiatedFromMember.setInt(Record[Idx++]);
1428 }
1429 }
1430
VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl * D)1431 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1432 ClassScopeFunctionSpecializationDecl *D) {
1433 VisitDecl(D);
1434 D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1435 }
1436
VisitFunctionTemplateDecl(FunctionTemplateDecl * D)1437 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1438 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1439
1440 if (ThisDeclID == Redecl.getFirstID()) {
1441 // This FunctionTemplateDecl owns a CommonPtr; read it.
1442
1443 // Read the function specialization declarations.
1444 // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
1445 // when reading the specialized FunctionDecl.
1446 unsigned NumSpecs = Record[Idx++];
1447 while (NumSpecs--)
1448 (void)ReadDecl(Record, Idx);
1449 }
1450 }
1451
VisitTemplateTypeParmDecl(TemplateTypeParmDecl * D)1452 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1453 VisitTypeDecl(D);
1454
1455 D->setDeclaredWithTypename(Record[Idx++]);
1456
1457 bool Inherited = Record[Idx++];
1458 TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1459 D->setDefaultArgument(DefArg, Inherited);
1460 }
1461
VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl * D)1462 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1463 VisitDeclaratorDecl(D);
1464 // TemplateParmPosition.
1465 D->setDepth(Record[Idx++]);
1466 D->setPosition(Record[Idx++]);
1467 if (D->isExpandedParameterPack()) {
1468 void **Data = reinterpret_cast<void **>(D + 1);
1469 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1470 Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1471 Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1472 }
1473 } else {
1474 // Rest of NonTypeTemplateParmDecl.
1475 D->ParameterPack = Record[Idx++];
1476 if (Record[Idx++]) {
1477 Expr *DefArg = Reader.ReadExpr(F);
1478 bool Inherited = Record[Idx++];
1479 D->setDefaultArgument(DefArg, Inherited);
1480 }
1481 }
1482 }
1483
VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl * D)1484 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1485 VisitTemplateDecl(D);
1486 // TemplateParmPosition.
1487 D->setDepth(Record[Idx++]);
1488 D->setPosition(Record[Idx++]);
1489 if (D->isExpandedParameterPack()) {
1490 void **Data = reinterpret_cast<void **>(D + 1);
1491 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1492 I != N; ++I)
1493 Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
1494 } else {
1495 // Rest of TemplateTemplateParmDecl.
1496 TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1497 bool IsInherited = Record[Idx++];
1498 D->setDefaultArgument(Arg, IsInherited);
1499 D->ParameterPack = Record[Idx++];
1500 }
1501 }
1502
VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl * D)1503 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1504 VisitRedeclarableTemplateDecl(D);
1505 }
1506
VisitStaticAssertDecl(StaticAssertDecl * D)1507 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1508 VisitDecl(D);
1509 D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
1510 D->AssertExprAndFailed.setInt(Record[Idx++]);
1511 D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
1512 D->RParenLoc = ReadSourceLocation(Record, Idx);
1513 }
1514
1515 std::pair<uint64_t, uint64_t>
VisitDeclContext(DeclContext * DC)1516 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1517 uint64_t LexicalOffset = Record[Idx++];
1518 uint64_t VisibleOffset = Record[Idx++];
1519 return std::make_pair(LexicalOffset, VisibleOffset);
1520 }
1521
1522 template <typename T>
1523 ASTDeclReader::RedeclarableResult
VisitRedeclarable(Redeclarable<T> * D)1524 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1525 DeclID FirstDeclID = ReadDeclID(Record, Idx);
1526
1527 // 0 indicates that this declaration was the only declaration of its entity,
1528 // and is used for space optimization.
1529 if (FirstDeclID == 0)
1530 FirstDeclID = ThisDeclID;
1531
1532 T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
1533 if (FirstDecl != D) {
1534 // We delay loading of the redeclaration chain to avoid deeply nested calls.
1535 // We temporarily set the first (canonical) declaration as the previous one
1536 // which is the one that matters and mark the real previous DeclID to be
1537 // loaded & attached later on.
1538 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
1539 }
1540
1541 // Note that this declaration has been deserialized.
1542 Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
1543
1544 // The result structure takes care to note that we need to load the
1545 // other declaration chains for this ID.
1546 return RedeclarableResult(Reader, FirstDeclID);
1547 }
1548
1549 /// \brief Attempts to merge the given declaration (D) with another declaration
1550 /// of the same entity.
1551 template<typename T>
mergeRedeclarable(Redeclarable<T> * D,RedeclarableResult & Redecl)1552 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D,
1553 RedeclarableResult &Redecl) {
1554 // If modules are not available, there is no reason to perform this merge.
1555 if (!Reader.getContext().getLangOpts().Modules)
1556 return;
1557
1558 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D))) {
1559 if (T *Existing = ExistingRes) {
1560 T *ExistingCanon = Existing->getCanonicalDecl();
1561 T *DCanon = static_cast<T*>(D)->getCanonicalDecl();
1562 if (ExistingCanon != DCanon) {
1563 // Have our redeclaration link point back at the canonical declaration
1564 // of the existing declaration, so that this declaration has the
1565 // appropriate canonical declaration.
1566 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
1567
1568 // When we merge a namespace, update its pointer to the first namespace.
1569 if (NamespaceDecl *Namespace
1570 = dyn_cast<NamespaceDecl>(static_cast<T*>(D))) {
1571 Namespace->AnonOrFirstNamespaceAndInline.setPointer(
1572 static_cast<NamespaceDecl *>(static_cast<void*>(ExistingCanon)));
1573 }
1574
1575 // Don't introduce DCanon into the set of pending declaration chains.
1576 Redecl.suppress();
1577
1578 // Introduce ExistingCanon into the set of pending declaration chains,
1579 // if in fact it came from a module file.
1580 if (ExistingCanon->isFromASTFile()) {
1581 GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID();
1582 assert(ExistingCanonID && "Unrecorded canonical declaration ID?");
1583 if (Reader.PendingDeclChainsKnown.insert(ExistingCanonID))
1584 Reader.PendingDeclChains.push_back(ExistingCanonID);
1585 }
1586
1587 // If this declaration was the canonical declaration, make a note of
1588 // that. We accept the linear algorithm here because the number of
1589 // unique canonical declarations of an entity should always be tiny.
1590 if (DCanon == static_cast<T*>(D)) {
1591 SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
1592 if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
1593 == Merged.end())
1594 Merged.push_back(Redecl.getFirstID());
1595
1596 // If ExistingCanon did not come from a module file, introduce the
1597 // first declaration that *does* come from a module file to the
1598 // set of pending declaration chains, so that we merge this
1599 // declaration.
1600 if (!ExistingCanon->isFromASTFile() &&
1601 Reader.PendingDeclChainsKnown.insert(Redecl.getFirstID()))
1602 Reader.PendingDeclChains.push_back(Merged[0]);
1603 }
1604 }
1605 }
1606 }
1607 }
1608
1609 //===----------------------------------------------------------------------===//
1610 // Attribute Reading
1611 //===----------------------------------------------------------------------===//
1612
1613 /// \brief Reads attributes from the current stream position.
ReadAttributes(ModuleFile & F,AttrVec & Attrs,const RecordData & Record,unsigned & Idx)1614 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
1615 const RecordData &Record, unsigned &Idx) {
1616 for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
1617 Attr *New = 0;
1618 attr::Kind Kind = (attr::Kind)Record[Idx++];
1619 SourceRange Range = ReadSourceRange(F, Record, Idx);
1620
1621 #include "clang/Serialization/AttrPCHRead.inc"
1622
1623 assert(New && "Unable to decode attribute?");
1624 Attrs.push_back(New);
1625 }
1626 }
1627
1628 //===----------------------------------------------------------------------===//
1629 // ASTReader Implementation
1630 //===----------------------------------------------------------------------===//
1631
1632 /// \brief Note that we have loaded the declaration with the given
1633 /// Index.
1634 ///
1635 /// This routine notes that this declaration has already been loaded,
1636 /// so that future GetDecl calls will return this declaration rather
1637 /// than trying to load a new declaration.
LoadedDecl(unsigned Index,Decl * D)1638 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
1639 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1640 DeclsLoaded[Index] = D;
1641 }
1642
1643
1644 /// \brief Determine whether the consumer will be interested in seeing
1645 /// this declaration (via HandleTopLevelDecl).
1646 ///
1647 /// This routine should return true for anything that might affect
1648 /// code generation, e.g., inline function definitions, Objective-C
1649 /// declarations with metadata, etc.
isConsumerInterestedIn(Decl * D)1650 static bool isConsumerInterestedIn(Decl *D) {
1651 // An ObjCMethodDecl is never considered as "interesting" because its
1652 // implementation container always is.
1653
1654 if (isa<FileScopeAsmDecl>(D) ||
1655 isa<ObjCProtocolDecl>(D) ||
1656 isa<ObjCImplDecl>(D))
1657 return true;
1658 if (VarDecl *Var = dyn_cast<VarDecl>(D))
1659 return Var->isFileVarDecl() &&
1660 Var->isThisDeclarationADefinition() == VarDecl::Definition;
1661 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1662 return Func->doesThisDeclarationHaveABody();
1663
1664 return false;
1665 }
1666
1667 /// \brief Get the correct cursor and offset for loading a declaration.
1668 ASTReader::RecordLocation
DeclCursorForID(DeclID ID,unsigned & RawLocation)1669 ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
1670 // See if there's an override.
1671 DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1672 if (It != ReplacedDecls.end()) {
1673 RawLocation = It->second.RawLoc;
1674 return RecordLocation(It->second.Mod, It->second.Offset);
1675 }
1676
1677 GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
1678 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
1679 ModuleFile *M = I->second;
1680 const DeclOffset &
1681 DOffs = M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
1682 RawLocation = DOffs.Loc;
1683 return RecordLocation(M, DOffs.BitOffset);
1684 }
1685
getLocalBitOffset(uint64_t GlobalOffset)1686 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
1687 ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
1688 = GlobalBitOffsetsMap.find(GlobalOffset);
1689
1690 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
1691 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
1692 }
1693
getGlobalBitOffset(ModuleFile & M,uint32_t LocalOffset)1694 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
1695 return LocalOffset + M.GlobalBitOffset;
1696 }
1697
1698 /// \brief Determine whether the two declarations refer to the same entity.
isSameEntity(NamedDecl * X,NamedDecl * Y)1699 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
1700 assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
1701
1702 if (X == Y)
1703 return true;
1704
1705 // Must be in the same context.
1706 if (!X->getDeclContext()->getRedeclContext()->Equals(
1707 Y->getDeclContext()->getRedeclContext()))
1708 return false;
1709
1710 // Two typedefs refer to the same entity if they have the same underlying
1711 // type.
1712 if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
1713 if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
1714 return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
1715 TypedefY->getUnderlyingType());
1716
1717 // Must have the same kind.
1718 if (X->getKind() != Y->getKind())
1719 return false;
1720
1721 // Objective-C classes and protocols with the same name always match.
1722 if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
1723 return true;
1724
1725 // Compatible tags match.
1726 if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
1727 TagDecl *TagY = cast<TagDecl>(Y);
1728 return (TagX->getTagKind() == TagY->getTagKind()) ||
1729 ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
1730 TagX->getTagKind() == TTK_Interface) &&
1731 (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
1732 TagY->getTagKind() == TTK_Interface));
1733 }
1734
1735 // Functions with the same type and linkage match.
1736 // FIXME: This needs to cope with function templates, merging of
1737 //prototyped/non-prototyped functions, etc.
1738 if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
1739 FunctionDecl *FuncY = cast<FunctionDecl>(Y);
1740 return (FuncX->getLinkage() == FuncY->getLinkage()) &&
1741 FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
1742 }
1743
1744 // Variables with the same type and linkage match.
1745 if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
1746 VarDecl *VarY = cast<VarDecl>(Y);
1747 return (VarX->getLinkage() == VarY->getLinkage()) &&
1748 VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
1749 }
1750
1751 // Namespaces with the same name and inlinedness match.
1752 if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
1753 NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
1754 return NamespaceX->isInline() == NamespaceY->isInline();
1755 }
1756
1757 // FIXME: Many other cases to implement.
1758 return false;
1759 }
1760
~FindExistingResult()1761 ASTDeclReader::FindExistingResult::~FindExistingResult() {
1762 if (!AddResult || Existing)
1763 return;
1764
1765 DeclContext *DC = New->getDeclContext()->getRedeclContext();
1766 if (DC->isTranslationUnit() && Reader.SemaObj) {
1767 Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName());
1768 } else if (DC->isNamespace()) {
1769 DC->addDecl(New);
1770 }
1771 }
1772
findExisting(NamedDecl * D)1773 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
1774 DeclarationName Name = D->getDeclName();
1775 if (!Name) {
1776 // Don't bother trying to find unnamed declarations.
1777 FindExistingResult Result(Reader, D, /*Existing=*/0);
1778 Result.suppress();
1779 return Result;
1780 }
1781
1782 DeclContext *DC = D->getDeclContext()->getRedeclContext();
1783 if (!DC->isFileContext())
1784 return FindExistingResult(Reader);
1785
1786 if (DC->isTranslationUnit() && Reader.SemaObj) {
1787 IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
1788 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
1789 IEnd = IdResolver.end();
1790 I != IEnd; ++I) {
1791 if (isSameEntity(*I, D))
1792 return FindExistingResult(Reader, D, *I);
1793 }
1794 }
1795
1796 if (DC->isNamespace()) {
1797 for (DeclContext::lookup_result R = DC->lookup(Name);
1798 R.first != R.second; ++R.first) {
1799 if (isSameEntity(*R.first, D))
1800 return FindExistingResult(Reader, D, *R.first);
1801 }
1802 }
1803
1804 return FindExistingResult(Reader, D, /*Existing=*/0);
1805 }
1806
attachPreviousDecl(Decl * D,Decl * previous)1807 void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) {
1808 assert(D && previous);
1809 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1810 TD->RedeclLink.setNext(cast<TagDecl>(previous));
1811 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1812 FD->RedeclLink.setNext(cast<FunctionDecl>(previous));
1813 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1814 VD->RedeclLink.setNext(cast<VarDecl>(previous));
1815 } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1816 TD->RedeclLink.setNext(cast<TypedefNameDecl>(previous));
1817 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1818 ID->RedeclLink.setNext(cast<ObjCInterfaceDecl>(previous));
1819 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1820 PD->RedeclLink.setNext(cast<ObjCProtocolDecl>(previous));
1821 } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1822 ND->RedeclLink.setNext(cast<NamespaceDecl>(previous));
1823 } else {
1824 RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1825 TD->RedeclLink.setNext(cast<RedeclarableTemplateDecl>(previous));
1826 }
1827 }
1828
attachLatestDecl(Decl * D,Decl * Latest)1829 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
1830 assert(D && Latest);
1831 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1832 TD->RedeclLink
1833 = Redeclarable<TagDecl>::LatestDeclLink(cast<TagDecl>(Latest));
1834 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1835 FD->RedeclLink
1836 = Redeclarable<FunctionDecl>::LatestDeclLink(cast<FunctionDecl>(Latest));
1837 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1838 VD->RedeclLink
1839 = Redeclarable<VarDecl>::LatestDeclLink(cast<VarDecl>(Latest));
1840 } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1841 TD->RedeclLink
1842 = Redeclarable<TypedefNameDecl>::LatestDeclLink(
1843 cast<TypedefNameDecl>(Latest));
1844 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1845 ID->RedeclLink
1846 = Redeclarable<ObjCInterfaceDecl>::LatestDeclLink(
1847 cast<ObjCInterfaceDecl>(Latest));
1848 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1849 PD->RedeclLink
1850 = Redeclarable<ObjCProtocolDecl>::LatestDeclLink(
1851 cast<ObjCProtocolDecl>(Latest));
1852 } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1853 ND->RedeclLink
1854 = Redeclarable<NamespaceDecl>::LatestDeclLink(
1855 cast<NamespaceDecl>(Latest));
1856 } else {
1857 RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1858 TD->RedeclLink
1859 = Redeclarable<RedeclarableTemplateDecl>::LatestDeclLink(
1860 cast<RedeclarableTemplateDecl>(Latest));
1861 }
1862 }
1863
1864 ASTReader::MergedDeclsMap::iterator
combineStoredMergedDecls(Decl * Canon,GlobalDeclID CanonID)1865 ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
1866 // If we don't have any stored merged declarations, just look in the
1867 // merged declarations set.
1868 StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
1869 if (StoredPos == StoredMergedDecls.end())
1870 return MergedDecls.find(Canon);
1871
1872 // Append the stored merged declarations to the merged declarations set.
1873 MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
1874 if (Pos == MergedDecls.end())
1875 Pos = MergedDecls.insert(std::make_pair(Canon,
1876 SmallVector<DeclID, 2>())).first;
1877 Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
1878 StoredMergedDecls.erase(StoredPos);
1879
1880 // Sort and uniquify the set of merged declarations.
1881 llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
1882 Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
1883 Pos->second.end());
1884 return Pos;
1885 }
1886
loadAndAttachPreviousDecl(Decl * D,serialization::DeclID ID)1887 void ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) {
1888 Decl *previous = GetDecl(ID);
1889 ASTDeclReader::attachPreviousDecl(D, previous);
1890 }
1891
1892 /// \brief Read the declaration at the given offset from the AST file.
ReadDeclRecord(DeclID ID)1893 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
1894 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
1895 unsigned RawLocation = 0;
1896 RecordLocation Loc = DeclCursorForID(ID, RawLocation);
1897 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
1898 // Keep track of where we are in the stream, then jump back there
1899 // after reading this declaration.
1900 SavedStreamPosition SavedPosition(DeclsCursor);
1901
1902 ReadingKindTracker ReadingKind(Read_Decl, *this);
1903
1904 // Note that we are loading a declaration record.
1905 Deserializing ADecl(this);
1906
1907 DeclsCursor.JumpToBit(Loc.Offset);
1908 RecordData Record;
1909 unsigned Code = DeclsCursor.ReadCode();
1910 unsigned Idx = 0;
1911 ASTDeclReader Reader(*this, *Loc.F, DeclsCursor, ID, RawLocation, Record,Idx);
1912
1913 Decl *D = 0;
1914 switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
1915 case DECL_CONTEXT_LEXICAL:
1916 case DECL_CONTEXT_VISIBLE:
1917 llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
1918 case DECL_TYPEDEF:
1919 D = TypedefDecl::CreateDeserialized(Context, ID);
1920 break;
1921 case DECL_TYPEALIAS:
1922 D = TypeAliasDecl::CreateDeserialized(Context, ID);
1923 break;
1924 case DECL_ENUM:
1925 D = EnumDecl::CreateDeserialized(Context, ID);
1926 break;
1927 case DECL_RECORD:
1928 D = RecordDecl::CreateDeserialized(Context, ID);
1929 break;
1930 case DECL_ENUM_CONSTANT:
1931 D = EnumConstantDecl::CreateDeserialized(Context, ID);
1932 break;
1933 case DECL_FUNCTION:
1934 D = FunctionDecl::CreateDeserialized(Context, ID);
1935 break;
1936 case DECL_LINKAGE_SPEC:
1937 D = LinkageSpecDecl::CreateDeserialized(Context, ID);
1938 break;
1939 case DECL_LABEL:
1940 D = LabelDecl::CreateDeserialized(Context, ID);
1941 break;
1942 case DECL_NAMESPACE:
1943 D = NamespaceDecl::CreateDeserialized(Context, ID);
1944 break;
1945 case DECL_NAMESPACE_ALIAS:
1946 D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
1947 break;
1948 case DECL_USING:
1949 D = UsingDecl::CreateDeserialized(Context, ID);
1950 break;
1951 case DECL_USING_SHADOW:
1952 D = UsingShadowDecl::CreateDeserialized(Context, ID);
1953 break;
1954 case DECL_USING_DIRECTIVE:
1955 D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
1956 break;
1957 case DECL_UNRESOLVED_USING_VALUE:
1958 D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
1959 break;
1960 case DECL_UNRESOLVED_USING_TYPENAME:
1961 D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
1962 break;
1963 case DECL_CXX_RECORD:
1964 D = CXXRecordDecl::CreateDeserialized(Context, ID);
1965 break;
1966 case DECL_CXX_METHOD:
1967 D = CXXMethodDecl::CreateDeserialized(Context, ID);
1968 break;
1969 case DECL_CXX_CONSTRUCTOR:
1970 D = CXXConstructorDecl::CreateDeserialized(Context, ID);
1971 break;
1972 case DECL_CXX_DESTRUCTOR:
1973 D = CXXDestructorDecl::CreateDeserialized(Context, ID);
1974 break;
1975 case DECL_CXX_CONVERSION:
1976 D = CXXConversionDecl::CreateDeserialized(Context, ID);
1977 break;
1978 case DECL_ACCESS_SPEC:
1979 D = AccessSpecDecl::CreateDeserialized(Context, ID);
1980 break;
1981 case DECL_FRIEND:
1982 D = FriendDecl::CreateDeserialized(Context, ID);
1983 break;
1984 case DECL_FRIEND_TEMPLATE:
1985 D = FriendTemplateDecl::CreateDeserialized(Context, ID);
1986 break;
1987 case DECL_CLASS_TEMPLATE:
1988 D = ClassTemplateDecl::CreateDeserialized(Context, ID);
1989 break;
1990 case DECL_CLASS_TEMPLATE_SPECIALIZATION:
1991 D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
1992 break;
1993 case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
1994 D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
1995 break;
1996 case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
1997 D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
1998 break;
1999 case DECL_FUNCTION_TEMPLATE:
2000 D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
2001 break;
2002 case DECL_TEMPLATE_TYPE_PARM:
2003 D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
2004 break;
2005 case DECL_NON_TYPE_TEMPLATE_PARM:
2006 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
2007 break;
2008 case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
2009 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2010 break;
2011 case DECL_TEMPLATE_TEMPLATE_PARM:
2012 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
2013 break;
2014 case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
2015 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
2016 Record[Idx++]);
2017 break;
2018 case DECL_TYPE_ALIAS_TEMPLATE:
2019 D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
2020 break;
2021 case DECL_STATIC_ASSERT:
2022 D = StaticAssertDecl::CreateDeserialized(Context, ID);
2023 break;
2024 case DECL_OBJC_METHOD:
2025 D = ObjCMethodDecl::CreateDeserialized(Context, ID);
2026 break;
2027 case DECL_OBJC_INTERFACE:
2028 D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
2029 break;
2030 case DECL_OBJC_IVAR:
2031 D = ObjCIvarDecl::CreateDeserialized(Context, ID);
2032 break;
2033 case DECL_OBJC_PROTOCOL:
2034 D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
2035 break;
2036 case DECL_OBJC_AT_DEFS_FIELD:
2037 D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
2038 break;
2039 case DECL_OBJC_CATEGORY:
2040 D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
2041 break;
2042 case DECL_OBJC_CATEGORY_IMPL:
2043 D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
2044 break;
2045 case DECL_OBJC_IMPLEMENTATION:
2046 D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
2047 break;
2048 case DECL_OBJC_COMPATIBLE_ALIAS:
2049 D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
2050 break;
2051 case DECL_OBJC_PROPERTY:
2052 D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
2053 break;
2054 case DECL_OBJC_PROPERTY_IMPL:
2055 D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
2056 break;
2057 case DECL_FIELD:
2058 D = FieldDecl::CreateDeserialized(Context, ID);
2059 break;
2060 case DECL_INDIRECTFIELD:
2061 D = IndirectFieldDecl::CreateDeserialized(Context, ID);
2062 break;
2063 case DECL_VAR:
2064 D = VarDecl::CreateDeserialized(Context, ID);
2065 break;
2066 case DECL_IMPLICIT_PARAM:
2067 D = ImplicitParamDecl::CreateDeserialized(Context, ID);
2068 break;
2069 case DECL_PARM_VAR:
2070 D = ParmVarDecl::CreateDeserialized(Context, ID);
2071 break;
2072 case DECL_FILE_SCOPE_ASM:
2073 D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
2074 break;
2075 case DECL_BLOCK:
2076 D = BlockDecl::CreateDeserialized(Context, ID);
2077 break;
2078 case DECL_CXX_BASE_SPECIFIERS:
2079 Error("attempt to read a C++ base-specifier record as a declaration");
2080 return 0;
2081 case DECL_IMPORT:
2082 // Note: last entry of the ImportDecl record is the number of stored source
2083 // locations.
2084 D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
2085 break;
2086 }
2087
2088 assert(D && "Unknown declaration reading AST file");
2089 LoadedDecl(Index, D);
2090 // Set the DeclContext before doing any deserialization, to make sure internal
2091 // calls to Decl::getASTContext() by Decl's methods will find the
2092 // TranslationUnitDecl without crashing.
2093 D->setDeclContext(Context.getTranslationUnitDecl());
2094 Reader.Visit(D);
2095
2096 // If this declaration is also a declaration context, get the
2097 // offsets for its tables of lexical and visible declarations.
2098 if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
2099 std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
2100 if (Offsets.first || Offsets.second) {
2101 if (Offsets.first != 0)
2102 DC->setHasExternalLexicalStorage(true);
2103 if (Offsets.second != 0)
2104 DC->setHasExternalVisibleStorage(true);
2105 if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
2106 Loc.F->DeclContextInfos[DC]))
2107 return 0;
2108 }
2109
2110 // Now add the pending visible updates for this decl context, if it has any.
2111 DeclContextVisibleUpdatesPending::iterator I =
2112 PendingVisibleUpdates.find(ID);
2113 if (I != PendingVisibleUpdates.end()) {
2114 // There are updates. This means the context has external visible
2115 // storage, even if the original stored version didn't.
2116 DC->setHasExternalVisibleStorage(true);
2117 DeclContextVisibleUpdates &U = I->second;
2118 for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
2119 UI != UE; ++UI) {
2120 DeclContextInfo &Info = UI->second->DeclContextInfos[DC];
2121 delete Info.NameLookupTableData;
2122 Info.NameLookupTableData = UI->first;
2123 }
2124 PendingVisibleUpdates.erase(I);
2125 }
2126 }
2127 assert(Idx == Record.size());
2128
2129 // Load any relevant update records.
2130 loadDeclUpdateRecords(ID, D);
2131
2132 // Load the categories after recursive loading is finished.
2133 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
2134 if (Class->isThisDeclarationADefinition())
2135 loadObjCCategories(ID, Class);
2136
2137 // If we have deserialized a declaration that has a definition the
2138 // AST consumer might need to know about, queue it.
2139 // We don't pass it to the consumer immediately because we may be in recursive
2140 // loading, and some declarations may still be initializing.
2141 if (isConsumerInterestedIn(D))
2142 InterestingDecls.push_back(D);
2143
2144 return D;
2145 }
2146
loadDeclUpdateRecords(serialization::DeclID ID,Decl * D)2147 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
2148 // The declaration may have been modified by files later in the chain.
2149 // If this is the case, read the record containing the updates from each file
2150 // and pass it to ASTDeclReader to make the modifications.
2151 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
2152 if (UpdI != DeclUpdateOffsets.end()) {
2153 FileOffsetsTy &UpdateOffsets = UpdI->second;
2154 for (FileOffsetsTy::iterator
2155 I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
2156 ModuleFile *F = I->first;
2157 uint64_t Offset = I->second;
2158 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
2159 SavedStreamPosition SavedPosition(Cursor);
2160 Cursor.JumpToBit(Offset);
2161 RecordData Record;
2162 unsigned Code = Cursor.ReadCode();
2163 unsigned RecCode = Cursor.ReadRecord(Code, Record);
2164 (void)RecCode;
2165 assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
2166
2167 unsigned Idx = 0;
2168 ASTDeclReader Reader(*this, *F, Cursor, ID, 0, Record, Idx);
2169 Reader.UpdateDecl(D, *F, Record);
2170 }
2171 }
2172 }
2173
2174 namespace {
2175 struct CompareLocalRedeclarationsInfoToID {
operator ()__anon572dbe620111::CompareLocalRedeclarationsInfoToID2176 bool operator()(const LocalRedeclarationsInfo &X, DeclID Y) {
2177 return X.FirstID < Y;
2178 }
2179
operator ()__anon572dbe620111::CompareLocalRedeclarationsInfoToID2180 bool operator()(DeclID X, const LocalRedeclarationsInfo &Y) {
2181 return X < Y.FirstID;
2182 }
2183
operator ()__anon572dbe620111::CompareLocalRedeclarationsInfoToID2184 bool operator()(const LocalRedeclarationsInfo &X,
2185 const LocalRedeclarationsInfo &Y) {
2186 return X.FirstID < Y.FirstID;
2187 }
operator ()__anon572dbe620111::CompareLocalRedeclarationsInfoToID2188 bool operator()(DeclID X, DeclID Y) {
2189 return X < Y;
2190 }
2191 };
2192
2193 /// \brief Module visitor class that finds all of the redeclarations of a
2194 ///
2195 class RedeclChainVisitor {
2196 ASTReader &Reader;
2197 SmallVectorImpl<DeclID> &SearchDecls;
2198 llvm::SmallPtrSet<Decl *, 16> &Deserialized;
2199 GlobalDeclID CanonID;
2200 llvm::SmallVector<Decl *, 4> Chain;
2201
2202 public:
RedeclChainVisitor(ASTReader & Reader,SmallVectorImpl<DeclID> & SearchDecls,llvm::SmallPtrSet<Decl *,16> & Deserialized,GlobalDeclID CanonID)2203 RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
2204 llvm::SmallPtrSet<Decl *, 16> &Deserialized,
2205 GlobalDeclID CanonID)
2206 : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
2207 CanonID(CanonID) {
2208 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2209 addToChain(Reader.GetDecl(SearchDecls[I]));
2210 }
2211
visit(ModuleFile & M,bool Preorder,void * UserData)2212 static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
2213 if (Preorder)
2214 return false;
2215
2216 return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
2217 }
2218
addToChain(Decl * D)2219 void addToChain(Decl *D) {
2220 if (!D)
2221 return;
2222
2223 if (Deserialized.erase(D))
2224 Chain.push_back(D);
2225 }
2226
searchForID(ModuleFile & M,GlobalDeclID GlobalID)2227 void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
2228 // Map global ID of the first declaration down to the local ID
2229 // used in this module file.
2230 DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
2231 if (!ID)
2232 return;
2233
2234 // Perform a binary search to find the local redeclarations for this
2235 // declaration (if any).
2236 const LocalRedeclarationsInfo *Result
2237 = std::lower_bound(M.RedeclarationsMap,
2238 M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
2239 ID, CompareLocalRedeclarationsInfoToID());
2240 if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
2241 Result->FirstID != ID) {
2242 // If we have a previously-canonical singleton declaration that was
2243 // merged into another redeclaration chain, create a trivial chain
2244 // for this single declaration so that it will get wired into the
2245 // complete redeclaration chain.
2246 if (GlobalID != CanonID &&
2247 GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
2248 GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
2249 addToChain(Reader.GetDecl(GlobalID));
2250 }
2251
2252 return;
2253 }
2254
2255 // Dig out all of the redeclarations.
2256 unsigned Offset = Result->Offset;
2257 unsigned N = M.RedeclarationChains[Offset];
2258 M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
2259 for (unsigned I = 0; I != N; ++I)
2260 addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
2261 }
2262
visit(ModuleFile & M)2263 bool visit(ModuleFile &M) {
2264 // Visit each of the declarations.
2265 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2266 searchForID(M, SearchDecls[I]);
2267 return false;
2268 }
2269
getChain() const2270 ArrayRef<Decl *> getChain() const {
2271 return Chain;
2272 }
2273 };
2274 }
2275
loadPendingDeclChain(serialization::GlobalDeclID ID)2276 void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
2277 Decl *D = GetDecl(ID);
2278 Decl *CanonDecl = D->getCanonicalDecl();
2279
2280 // Determine the set of declaration IDs we'll be searching for.
2281 llvm::SmallVector<DeclID, 1> SearchDecls;
2282 GlobalDeclID CanonID = 0;
2283 if (D == CanonDecl) {
2284 SearchDecls.push_back(ID); // Always first.
2285 CanonID = ID;
2286 }
2287 MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
2288 if (MergedPos != MergedDecls.end())
2289 SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
2290
2291 // Build up the list of redeclarations.
2292 RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
2293 ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
2294
2295 // Retrieve the chains.
2296 ArrayRef<Decl *> Chain = Visitor.getChain();
2297 if (Chain.empty())
2298 return;
2299
2300 // Hook up the chains.
2301 Decl *MostRecent = CanonDecl->getMostRecentDecl();
2302 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2303 if (Chain[I] == CanonDecl)
2304 continue;
2305
2306 ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent);
2307 MostRecent = Chain[I];
2308 }
2309
2310 ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
2311 }
2312
2313 namespace {
2314 struct CompareObjCCategoriesInfo {
operator ()__anon572dbe620211::CompareObjCCategoriesInfo2315 bool operator()(const ObjCCategoriesInfo &X, DeclID Y) {
2316 return X.DefinitionID < Y;
2317 }
2318
operator ()__anon572dbe620211::CompareObjCCategoriesInfo2319 bool operator()(DeclID X, const ObjCCategoriesInfo &Y) {
2320 return X < Y.DefinitionID;
2321 }
2322
operator ()__anon572dbe620211::CompareObjCCategoriesInfo2323 bool operator()(const ObjCCategoriesInfo &X,
2324 const ObjCCategoriesInfo &Y) {
2325 return X.DefinitionID < Y.DefinitionID;
2326 }
operator ()__anon572dbe620211::CompareObjCCategoriesInfo2327 bool operator()(DeclID X, DeclID Y) {
2328 return X < Y;
2329 }
2330 };
2331
2332 /// \brief Given an ObjC interface, goes through the modules and links to the
2333 /// interface all the categories for it.
2334 class ObjCCategoriesVisitor {
2335 ASTReader &Reader;
2336 serialization::GlobalDeclID InterfaceID;
2337 ObjCInterfaceDecl *Interface;
2338 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized;
2339 unsigned PreviousGeneration;
2340 ObjCCategoryDecl *Tail;
2341 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
2342
add(ObjCCategoryDecl * Cat)2343 void add(ObjCCategoryDecl *Cat) {
2344 // Only process each category once.
2345 if (!Deserialized.erase(Cat))
2346 return;
2347
2348 // Check for duplicate categories.
2349 if (Cat->getDeclName()) {
2350 ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
2351 if (Existing &&
2352 Reader.getOwningModuleFile(Existing)
2353 != Reader.getOwningModuleFile(Cat)) {
2354 // FIXME: We should not warn for duplicates in diamond:
2355 //
2356 // MT //
2357 // / \ //
2358 // ML MR //
2359 // \ / //
2360 // MB //
2361 //
2362 // If there are duplicates in ML/MR, there will be warning when
2363 // creating MB *and* when importing MB. We should not warn when
2364 // importing.
2365 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
2366 << Interface->getDeclName() << Cat->getDeclName();
2367 Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
2368 } else if (!Existing) {
2369 // Record this category.
2370 Existing = Cat;
2371 }
2372 }
2373
2374 // Add this category to the end of the chain.
2375 if (Tail)
2376 ASTDeclReader::setNextObjCCategory(Tail, Cat);
2377 else
2378 Interface->setCategoryList(Cat);
2379 Tail = Cat;
2380 }
2381
2382 public:
ObjCCategoriesVisitor(ASTReader & Reader,serialization::GlobalDeclID InterfaceID,ObjCInterfaceDecl * Interface,llvm::SmallPtrSet<ObjCCategoryDecl *,16> & Deserialized,unsigned PreviousGeneration)2383 ObjCCategoriesVisitor(ASTReader &Reader,
2384 serialization::GlobalDeclID InterfaceID,
2385 ObjCInterfaceDecl *Interface,
2386 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized,
2387 unsigned PreviousGeneration)
2388 : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
2389 Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
2390 Tail(0)
2391 {
2392 // Populate the name -> category map with the set of known categories.
2393 for (ObjCCategoryDecl *Cat = Interface->getCategoryList(); Cat;
2394 Cat = Cat->getNextClassCategory()) {
2395 if (Cat->getDeclName())
2396 NameCategoryMap[Cat->getDeclName()] = Cat;
2397
2398 // Keep track of the tail of the category list.
2399 Tail = Cat;
2400 }
2401 }
2402
visit(ModuleFile & M,void * UserData)2403 static bool visit(ModuleFile &M, void *UserData) {
2404 return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
2405 }
2406
visit(ModuleFile & M)2407 bool visit(ModuleFile &M) {
2408 // If we've loaded all of the category information we care about from
2409 // this module file, we're done.
2410 if (M.Generation <= PreviousGeneration)
2411 return true;
2412
2413 // Map global ID of the definition down to the local ID used in this
2414 // module file. If there is no such mapping, we'll find nothing here
2415 // (or in any module it imports).
2416 DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
2417 if (!LocalID)
2418 return true;
2419
2420 // Perform a binary search to find the local redeclarations for this
2421 // declaration (if any).
2422 const ObjCCategoriesInfo *Result
2423 = std::lower_bound(M.ObjCCategoriesMap,
2424 M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
2425 LocalID, CompareObjCCategoriesInfo());
2426 if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
2427 Result->DefinitionID != LocalID) {
2428 // We didn't find anything. If the class definition is in this module
2429 // file, then the module files it depends on cannot have any categories,
2430 // so suppress further lookup.
2431 return Reader.isDeclIDFromModule(InterfaceID, M);
2432 }
2433
2434 // We found something. Dig out all of the categories.
2435 unsigned Offset = Result->Offset;
2436 unsigned N = M.ObjCCategories[Offset];
2437 M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
2438 for (unsigned I = 0; I != N; ++I)
2439 add(cast_or_null<ObjCCategoryDecl>(
2440 Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
2441 return true;
2442 }
2443 };
2444 }
2445
loadObjCCategories(serialization::GlobalDeclID ID,ObjCInterfaceDecl * D,unsigned PreviousGeneration)2446 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
2447 ObjCInterfaceDecl *D,
2448 unsigned PreviousGeneration) {
2449 ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
2450 PreviousGeneration);
2451 ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
2452 }
2453
UpdateDecl(Decl * D,ModuleFile & ModuleFile,const RecordData & Record)2454 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
2455 const RecordData &Record) {
2456 unsigned Idx = 0;
2457 while (Idx < Record.size()) {
2458 switch ((DeclUpdateKind)Record[Idx++]) {
2459 case UPD_CXX_ADDED_IMPLICIT_MEMBER:
2460 cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(ModuleFile, Record, Idx));
2461 break;
2462
2463 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
2464 // It will be added to the template's specializations set when loaded.
2465 (void)Reader.ReadDecl(ModuleFile, Record, Idx);
2466 break;
2467
2468 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
2469 NamespaceDecl *Anon
2470 = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
2471
2472 // Each module has its own anonymous namespace, which is disjoint from
2473 // any other module's anonymous namespaces, so don't attach the anonymous
2474 // namespace at all.
2475 if (ModuleFile.Kind != MK_Module) {
2476 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
2477 TU->setAnonymousNamespace(Anon);
2478 else
2479 cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
2480 }
2481 break;
2482 }
2483
2484 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
2485 cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
2486 Reader.ReadSourceLocation(ModuleFile, Record, Idx));
2487 break;
2488 }
2489 }
2490 }
2491