1 //===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the ASTReader::ReadDeclRecord method, which is the
11 // entrypoint for loading a decl.
13 //===----------------------------------------------------------------------===//
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;
32 //===----------------------------------------------------------------------===//
33 // Declaration deserialization
34 //===----------------------------------------------------------------------===//
37 class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
40 const DeclID ThisDeclID;
41 const unsigned RawLocation;
42 typedef ASTReader::RecordData RecordData;
43 const RecordData &Record;
45 TypeID TypeIDForTypeDecl;
47 DeclID DeclContextIDForTemplateParmDecl;
48 DeclID LexicalDeclContextIDForTemplateParmDecl;
52 uint64_t GetCurrentCursorOffset();
54 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
55 return Reader.ReadSourceLocation(F, R, I);
58 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
59 return Reader.ReadSourceRange(F, R, I);
62 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
63 return Reader.GetTypeSourceInfo(F, R, I);
66 serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
67 return Reader.ReadDeclID(F, R, I);
70 Decl *ReadDecl(const RecordData &R, unsigned &I) {
71 return Reader.ReadDecl(F, R, I);
75 T *ReadDeclAs(const RecordData &R, unsigned &I) {
76 return Reader.ReadDeclAs<T>(F, R, I);
79 void ReadQualifierInfo(QualifierInfo &Info,
80 const RecordData &R, unsigned &I) {
81 Reader.ReadQualifierInfo(F, Info, R, I);
84 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
85 const RecordData &R, unsigned &I) {
86 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
89 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
90 const RecordData &R, unsigned &I) {
91 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
94 serialization::SubmoduleID readSubmoduleID(const RecordData &R,
99 return Reader.getGlobalSubmoduleID(F, R[I++]);
102 Module *readModule(const RecordData &R, unsigned &I) {
103 return Reader.getSubmodule(readSubmoduleID(R, I));
106 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
107 const RecordData &R, unsigned &I);
109 /// \brief RAII class used to capture the first ID within a redeclaration
110 /// chain and to introduce it into the list of pending redeclaration chains
113 /// The caller can choose not to introduce this ID into the redeclaration
114 /// chain by calling \c suppress().
115 class RedeclarableResult {
117 GlobalDeclID FirstID;
120 void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION;
123 RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID)
124 : Reader(Reader), FirstID(FirstID), Owning(true) { }
126 RedeclarableResult(const RedeclarableResult &Other)
127 : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning)
129 Other.Owning = false;
132 ~RedeclarableResult() {
133 // FIXME: We want to suppress this when the declaration is local to
134 // a function, since there's no reason to search other AST files
135 // for redeclarations (they can't exist). However, this is hard to
136 // do locally because the declaration hasn't necessarily loaded its
137 // declaration context yet. Also, local externs still have the function
138 // as their (semantic) declaration context, which is wrong and would
139 // break this optimize.
141 if (FirstID && Owning && Reader.PendingDeclChainsKnown.insert(FirstID))
142 Reader.PendingDeclChains.push_back(FirstID);
145 /// \brief Retrieve the first ID.
146 GlobalDeclID getFirstID() const { return FirstID; }
148 /// \brief Do not introduce this declaration ID into the set of pending
149 /// declaration chains.
155 /// \brief Class used to capture the result of searching for an existing
156 /// declaration of a specific kind and name, along with the ability
157 /// to update the place where this result was found (the declaration
158 /// chain hanging off an identifier or the DeclContext we searched in)
160 class FindExistingResult {
164 mutable bool AddResult;
166 void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION;
169 FindExistingResult(ASTReader &Reader)
170 : Reader(Reader), New(0), Existing(0), AddResult(false) { }
172 FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing)
173 : Reader(Reader), New(New), Existing(Existing), AddResult(true) { }
175 FindExistingResult(const FindExistingResult &Other)
176 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
177 AddResult(Other.AddResult)
179 Other.AddResult = false;
182 ~FindExistingResult();
184 /// \brief Suppress the addition of this result into the known set of
186 void suppress() { AddResult = false; }
188 operator NamedDecl*() const { return Existing; }
191 operator T*() const { return dyn_cast_or_null<T>(Existing); }
194 FindExistingResult findExisting(NamedDecl *D);
197 ASTDeclReader(ASTReader &Reader, ModuleFile &F,
199 unsigned RawLocation,
200 const RecordData &Record, unsigned &Idx)
201 : Reader(Reader), F(F), ThisDeclID(thisDeclID),
202 RawLocation(RawLocation), Record(Record), Idx(Idx),
203 TypeIDForTypeDecl(0), HasPendingBody(false) { }
205 static void attachPreviousDecl(Decl *D, Decl *previous);
206 static void attachLatestDecl(Decl *D, Decl *latest);
208 /// \brief Determine whether this declaration has a pending body.
209 bool hasPendingBody() const { return HasPendingBody; }
213 void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
214 const RecordData &Record);
216 static void setNextObjCCategory(ObjCCategoryDecl *Cat,
217 ObjCCategoryDecl *Next) {
218 Cat->NextClassCategory = Next;
221 void VisitDecl(Decl *D);
222 void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
223 void VisitNamedDecl(NamedDecl *ND);
224 void VisitLabelDecl(LabelDecl *LD);
225 void VisitNamespaceDecl(NamespaceDecl *D);
226 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
227 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
228 void VisitTypeDecl(TypeDecl *TD);
229 void VisitTypedefNameDecl(TypedefNameDecl *TD);
230 void VisitTypedefDecl(TypedefDecl *TD);
231 void VisitTypeAliasDecl(TypeAliasDecl *TD);
232 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
233 void VisitTagDecl(TagDecl *TD);
234 void VisitEnumDecl(EnumDecl *ED);
235 void VisitRecordDecl(RecordDecl *RD);
236 void VisitCXXRecordDecl(CXXRecordDecl *D);
237 void VisitClassTemplateSpecializationDecl(
238 ClassTemplateSpecializationDecl *D);
239 void VisitClassTemplatePartialSpecializationDecl(
240 ClassTemplatePartialSpecializationDecl *D);
241 void VisitClassScopeFunctionSpecializationDecl(
242 ClassScopeFunctionSpecializationDecl *D);
243 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
244 void VisitValueDecl(ValueDecl *VD);
245 void VisitEnumConstantDecl(EnumConstantDecl *ECD);
246 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
247 void VisitDeclaratorDecl(DeclaratorDecl *DD);
248 void VisitFunctionDecl(FunctionDecl *FD);
249 void VisitCXXMethodDecl(CXXMethodDecl *D);
250 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
251 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
252 void VisitCXXConversionDecl(CXXConversionDecl *D);
253 void VisitFieldDecl(FieldDecl *FD);
254 void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
255 void VisitVarDecl(VarDecl *VD);
256 void VisitImplicitParamDecl(ImplicitParamDecl *PD);
257 void VisitParmVarDecl(ParmVarDecl *PD);
258 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
259 void VisitTemplateDecl(TemplateDecl *D);
260 RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
261 void VisitClassTemplateDecl(ClassTemplateDecl *D);
262 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
263 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
264 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
265 void VisitUsingDecl(UsingDecl *D);
266 void VisitUsingShadowDecl(UsingShadowDecl *D);
267 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
268 void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
269 void VisitImportDecl(ImportDecl *D);
270 void VisitAccessSpecDecl(AccessSpecDecl *D);
271 void VisitFriendDecl(FriendDecl *D);
272 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
273 void VisitStaticAssertDecl(StaticAssertDecl *D);
274 void VisitBlockDecl(BlockDecl *BD);
276 std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
279 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
282 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
284 // FIXME: Reorder according to DeclNodes.td?
285 void VisitObjCMethodDecl(ObjCMethodDecl *D);
286 void VisitObjCContainerDecl(ObjCContainerDecl *D);
287 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
288 void VisitObjCIvarDecl(ObjCIvarDecl *D);
289 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
290 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
291 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
292 void VisitObjCImplDecl(ObjCImplDecl *D);
293 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
294 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
295 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
296 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
297 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
301 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
302 return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
305 void ASTDeclReader::Visit(Decl *D) {
306 DeclVisitor<ASTDeclReader, void>::Visit(D);
308 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
310 DeclaratorDecl::ExtInfo *Info =
311 DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
313 GetTypeSourceInfo(Record, Idx);
316 DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
320 if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
321 // if we have a fully initialized TypeDecl, we can safely read its type now.
322 TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
323 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
324 // if we have a fully initialized TypeDecl, we can safely read its type now.
325 ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
326 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
327 // FunctionDecl's body was written last after all other Stmts/Exprs.
328 // We only read it if FD doesn't already have a body (e.g., from another
330 // FIXME: Also consider = default and = delete.
331 // FIXME: Can we diagnose ODR violations somehow?
333 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
334 HasPendingBody = true;
336 } else if (D->isTemplateParameter()) {
337 // If we have a fully initialized template parameter, we can now
338 // set its DeclContext.
339 DeclContext *SemaDC = cast<DeclContext>(
340 Reader.GetDecl(DeclContextIDForTemplateParmDecl));
341 DeclContext *LexicalDC = cast<DeclContext>(
342 Reader.GetDecl(LexicalDeclContextIDForTemplateParmDecl));
343 D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
347 void ASTDeclReader::VisitDecl(Decl *D) {
348 if (D->isTemplateParameter()) {
349 // We don't want to deserialize the DeclContext of a template
350 // parameter immediately, because the template parameter might be
351 // used in the formulation of its DeclContext. Use the translation
352 // unit DeclContext as a placeholder.
353 DeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
354 LexicalDeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
355 D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
357 DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
358 DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
359 // Avoid calling setLexicalDeclContext() directly because it uses
360 // Decl::getASTContext() internally which is unsafe during derialization.
361 D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
363 D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
364 D->setInvalidDecl(Record[Idx++]);
365 if (Record[Idx++]) { // hasAttrs
367 Reader.ReadAttributes(F, Attrs, Record, Idx);
368 // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
369 // internally which is unsafe during derialization.
370 D->setAttrsImpl(Attrs, Reader.getContext());
372 D->setImplicit(Record[Idx++]);
373 D->setUsed(Record[Idx++]);
374 D->setReferenced(Record[Idx++]);
375 D->setTopLevelDeclInObjCContainer(Record[Idx++]);
376 D->setAccess((AccessSpecifier)Record[Idx++]);
377 D->FromASTFile = true;
378 D->setModulePrivate(Record[Idx++]);
379 D->Hidden = D->isModulePrivate();
381 // Determine whether this declaration is part of a (sub)module. If so, it
382 // may not yet be visible.
383 if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
384 // Store the owning submodule ID in the declaration.
385 D->setOwningModuleID(SubmoduleID);
387 // Module-private declarations are never visible, so there is no work to do.
388 if (!D->isModulePrivate()) {
389 if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
390 if (Owner->NameVisibility != Module::AllVisible) {
391 // The owning module is not visible. Mark this declaration as hidden.
394 // Note that this declaration was hidden because its owning module is
396 Reader.HiddenNamesMap[Owner].push_back(D);
403 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
404 llvm_unreachable("Translation units are not serialized");
407 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
409 ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
412 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
414 TD->setLocStart(ReadSourceLocation(Record, Idx));
415 // Delay type reading until after we have fully initialized the decl.
416 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
419 void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
420 RedeclarableResult Redecl = VisitRedeclarable(TD);
423 TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
424 mergeRedeclarable(TD, Redecl);
427 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
428 VisitTypedefNameDecl(TD);
431 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
432 VisitTypedefNameDecl(TD);
435 void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
436 RedeclarableResult Redecl = VisitRedeclarable(TD);
439 TD->IdentifierNamespace = Record[Idx++];
440 TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
441 TD->setCompleteDefinition(Record[Idx++]);
442 TD->setEmbeddedInDeclarator(Record[Idx++]);
443 TD->setFreeStanding(Record[Idx++]);
444 TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
446 if (Record[Idx++]) { // hasExtInfo
447 TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
448 ReadQualifierInfo(*Info, Record, Idx);
449 TD->TypedefNameDeclOrQualifier = Info;
451 TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(Record, Idx));
453 mergeRedeclarable(TD, Redecl);
456 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
458 if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
459 ED->setIntegerTypeSourceInfo(TI);
461 ED->setIntegerType(Reader.readType(F, Record, Idx));
462 ED->setPromotionType(Reader.readType(F, Record, Idx));
463 ED->setNumPositiveBits(Record[Idx++]);
464 ED->setNumNegativeBits(Record[Idx++]);
465 ED->IsScoped = Record[Idx++];
466 ED->IsScopedUsingClassTag = Record[Idx++];
467 ED->IsFixed = Record[Idx++];
469 if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
470 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
471 SourceLocation POI = ReadSourceLocation(Record, Idx);
472 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
473 ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
477 void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
479 RD->setHasFlexibleArrayMember(Record[Idx++]);
480 RD->setAnonymousStructOrUnion(Record[Idx++]);
481 RD->setHasObjectMember(Record[Idx++]);
484 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
486 VD->setType(Reader.readType(F, Record, Idx));
489 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
492 ECD->setInitExpr(Reader.ReadExpr(F));
493 ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
496 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
498 DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
499 if (Record[Idx++]) { // hasExtInfo
500 DeclaratorDecl::ExtInfo *Info
501 = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
502 ReadQualifierInfo(*Info, Record, Idx);
507 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
508 RedeclarableResult Redecl = VisitRedeclarable(FD);
509 VisitDeclaratorDecl(FD);
511 ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
512 FD->IdentifierNamespace = Record[Idx++];
514 // FunctionDecl's body is handled last at ASTDeclReader::Visit,
515 // after everything else is read.
517 FD->SClass = (StorageClass)Record[Idx++];
518 FD->SClassAsWritten = (StorageClass)Record[Idx++];
519 FD->IsInline = Record[Idx++];
520 FD->IsInlineSpecified = Record[Idx++];
521 FD->IsVirtualAsWritten = Record[Idx++];
522 FD->IsPure = Record[Idx++];
523 FD->HasInheritedPrototype = Record[Idx++];
524 FD->HasWrittenPrototype = Record[Idx++];
525 FD->IsDeleted = Record[Idx++];
526 FD->IsTrivial = Record[Idx++];
527 FD->IsDefaulted = Record[Idx++];
528 FD->IsExplicitlyDefaulted = Record[Idx++];
529 FD->HasImplicitReturnZero = Record[Idx++];
530 FD->IsConstexpr = Record[Idx++];
531 FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
533 switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
534 case FunctionDecl::TK_NonTemplate:
535 mergeRedeclarable(FD, Redecl);
537 case FunctionDecl::TK_FunctionTemplate:
538 FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
541 case FunctionDecl::TK_MemberSpecialization: {
542 FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
543 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
544 SourceLocation POI = ReadSourceLocation(Record, Idx);
545 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
546 FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
549 case FunctionDecl::TK_FunctionTemplateSpecialization: {
550 FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
552 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
554 // Template arguments.
555 SmallVector<TemplateArgument, 8> TemplArgs;
556 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
558 // Template args as written.
559 SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
560 SourceLocation LAngleLoc, RAngleLoc;
561 bool HasTemplateArgumentsAsWritten = Record[Idx++];
562 if (HasTemplateArgumentsAsWritten) {
563 unsigned NumTemplateArgLocs = Record[Idx++];
564 TemplArgLocs.reserve(NumTemplateArgLocs);
565 for (unsigned i=0; i != NumTemplateArgLocs; ++i)
566 TemplArgLocs.push_back(
567 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
569 LAngleLoc = ReadSourceLocation(Record, Idx);
570 RAngleLoc = ReadSourceLocation(Record, Idx);
573 SourceLocation POI = ReadSourceLocation(Record, Idx);
575 ASTContext &C = Reader.getContext();
576 TemplateArgumentList *TemplArgList
577 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
578 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
579 for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
580 TemplArgsInfo.addArgument(TemplArgLocs[i]);
581 FunctionTemplateSpecializationInfo *FTInfo
582 = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
584 HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0,
586 FD->TemplateOrSpecialization = FTInfo;
588 if (FD->isCanonicalDecl()) { // if canonical add to template's set.
589 // The template that contains the specializations set. It's not safe to
590 // use getCanonicalDecl on Template since it may still be initializing.
591 FunctionTemplateDecl *CanonTemplate
592 = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
593 // Get the InsertPos by FindNodeOrInsertPos() instead of calling
594 // InsertNode(FTInfo) directly to avoid the getASTContext() call in
595 // FunctionTemplateSpecializationInfo's Profile().
596 // We avoid getASTContext because a decl in the parent hierarchy may
598 llvm::FoldingSetNodeID ID;
599 FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
600 TemplArgs.size(), C);
602 CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
604 CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
606 assert(0 && "Another specialization already inserted!");
610 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
612 UnresolvedSet<8> TemplDecls;
613 unsigned NumTemplates = Record[Idx++];
614 while (NumTemplates--)
615 TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
618 TemplateArgumentListInfo TemplArgs;
619 unsigned NumArgs = Record[Idx++];
621 TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
622 TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
623 TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
625 FD->setDependentTemplateSpecialization(Reader.getContext(),
626 TemplDecls, TemplArgs);
631 // Read in the parameters.
632 unsigned NumParams = Record[Idx++];
633 SmallVector<ParmVarDecl *, 16> Params;
634 Params.reserve(NumParams);
635 for (unsigned I = 0; I != NumParams; ++I)
636 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
637 FD->setParams(Reader.getContext(), Params);
640 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
643 // Load the body on-demand. Most clients won't care, because method
644 // definitions rarely show up in headers.
645 Reader.PendingBodies[MD] = GetCurrentCursorOffset();
646 HasPendingBody = true;
647 MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
648 MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
650 MD->setInstanceMethod(Record[Idx++]);
651 MD->setVariadic(Record[Idx++]);
652 MD->setPropertyAccessor(Record[Idx++]);
653 MD->setDefined(Record[Idx++]);
654 MD->IsOverriding = Record[Idx++];
656 MD->IsRedeclaration = Record[Idx++];
657 MD->HasRedeclaration = Record[Idx++];
658 if (MD->HasRedeclaration)
659 Reader.getContext().setObjCMethodRedeclaration(MD,
660 ReadDeclAs<ObjCMethodDecl>(Record, Idx));
662 MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
663 MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
664 MD->SetRelatedResultType(Record[Idx++]);
665 MD->setResultType(Reader.readType(F, Record, Idx));
666 MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
667 MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
668 unsigned NumParams = Record[Idx++];
669 SmallVector<ParmVarDecl *, 16> Params;
670 Params.reserve(NumParams);
671 for (unsigned I = 0; I != NumParams; ++I)
672 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
674 MD->SelLocsKind = Record[Idx++];
675 unsigned NumStoredSelLocs = Record[Idx++];
676 SmallVector<SourceLocation, 16> SelLocs;
677 SelLocs.reserve(NumStoredSelLocs);
678 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
679 SelLocs.push_back(ReadSourceLocation(Record, Idx));
681 MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
684 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
686 CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
687 CD->setAtEndRange(ReadSourceRange(Record, Idx));
690 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
691 RedeclarableResult Redecl = VisitRedeclarable(ID);
692 VisitObjCContainerDecl(ID);
693 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
694 mergeRedeclarable(ID, Redecl);
697 // Read the definition.
698 ID->allocateDefinitionData();
700 // Set the definition data of the canonical declaration, so other
701 // redeclarations will see it.
702 ID->getCanonicalDecl()->Data = ID->Data;
704 ObjCInterfaceDecl::DefinitionData &Data = ID->data();
706 // Read the superclass.
707 Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
708 Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
710 Data.EndLoc = ReadSourceLocation(Record, Idx);
712 // Read the directly referenced protocols and their SourceLocations.
713 unsigned NumProtocols = Record[Idx++];
714 SmallVector<ObjCProtocolDecl *, 16> Protocols;
715 Protocols.reserve(NumProtocols);
716 for (unsigned I = 0; I != NumProtocols; ++I)
717 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
718 SmallVector<SourceLocation, 16> ProtoLocs;
719 ProtoLocs.reserve(NumProtocols);
720 for (unsigned I = 0; I != NumProtocols; ++I)
721 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
722 ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
723 Reader.getContext());
725 // Read the transitive closure of protocols referenced by this class.
726 NumProtocols = Record[Idx++];
728 Protocols.reserve(NumProtocols);
729 for (unsigned I = 0; I != NumProtocols; ++I)
730 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
731 ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
732 Reader.getContext());
734 // We will rebuild this list lazily.
737 // Note that we have deserialized a definition.
738 Reader.PendingDefinitions.insert(ID);
740 // Note that we've loaded this Objective-C class.
741 Reader.ObjCClassesLoaded.push_back(ID);
743 ID->Data = ID->getCanonicalDecl()->Data;
747 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
749 IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
750 // This field will be built lazily.
752 bool synth = Record[Idx++];
753 IVD->setSynthesize(synth);
756 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
757 RedeclarableResult Redecl = VisitRedeclarable(PD);
758 VisitObjCContainerDecl(PD);
759 mergeRedeclarable(PD, Redecl);
762 // Read the definition.
763 PD->allocateDefinitionData();
765 // Set the definition data of the canonical declaration, so other
766 // redeclarations will see it.
767 PD->getCanonicalDecl()->Data = PD->Data;
769 unsigned NumProtoRefs = Record[Idx++];
770 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
771 ProtoRefs.reserve(NumProtoRefs);
772 for (unsigned I = 0; I != NumProtoRefs; ++I)
773 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
774 SmallVector<SourceLocation, 16> ProtoLocs;
775 ProtoLocs.reserve(NumProtoRefs);
776 for (unsigned I = 0; I != NumProtoRefs; ++I)
777 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
778 PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
779 Reader.getContext());
781 // Note that we have deserialized a definition.
782 Reader.PendingDefinitions.insert(PD);
784 PD->Data = PD->getCanonicalDecl()->Data;
788 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
792 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
793 VisitObjCContainerDecl(CD);
794 CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
795 CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
796 CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
798 // Note that this category has been deserialized. We do this before
799 // deserializing the interface declaration, so that it will consider this
801 Reader.CategoriesDeserialized.insert(CD);
803 CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
804 unsigned NumProtoRefs = Record[Idx++];
805 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
806 ProtoRefs.reserve(NumProtoRefs);
807 for (unsigned I = 0; I != NumProtoRefs; ++I)
808 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
809 SmallVector<SourceLocation, 16> ProtoLocs;
810 ProtoLocs.reserve(NumProtoRefs);
811 for (unsigned I = 0; I != NumProtoRefs; ++I)
812 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
813 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
814 Reader.getContext());
817 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
819 CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
822 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
824 D->setAtLoc(ReadSourceLocation(Record, Idx));
825 D->setLParenLoc(ReadSourceLocation(Record, Idx));
826 D->setType(GetTypeSourceInfo(Record, Idx));
827 // FIXME: stable encoding
828 D->setPropertyAttributes(
829 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
830 D->setPropertyAttributesAsWritten(
831 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
832 // FIXME: stable encoding
833 D->setPropertyImplementation(
834 (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
835 D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
836 D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
837 D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
838 D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
839 D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
842 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
843 VisitObjCContainerDecl(D);
844 D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
847 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
848 VisitObjCImplDecl(D);
849 D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
850 D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
853 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
854 VisitObjCImplDecl(D);
855 D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
856 D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
857 D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
858 D->setHasNonZeroConstructors(Record[Idx++]);
859 D->setHasDestructors(Record[Idx++]);
860 llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
861 = Reader.ReadCXXCtorInitializers(F, Record, Idx);
865 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
867 D->setAtLoc(ReadSourceLocation(Record, Idx));
868 D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
869 D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
870 D->IvarLoc = ReadSourceLocation(Record, Idx);
871 D->setGetterCXXConstructor(Reader.ReadExpr(F));
872 D->setSetterCXXAssignment(Reader.ReadExpr(F));
875 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
876 VisitDeclaratorDecl(FD);
877 FD->Mutable = Record[Idx++];
878 if (int BitWidthOrInitializer = Record[Idx++]) {
879 FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1);
880 FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F));
882 if (!FD->getDeclName()) {
883 if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
884 Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
888 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
891 FD->ChainingSize = Record[Idx++];
892 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
893 FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
895 for (unsigned I = 0; I != FD->ChainingSize; ++I)
896 FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
899 void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
900 RedeclarableResult Redecl = VisitRedeclarable(VD);
901 VisitDeclaratorDecl(VD);
903 VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
904 VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
905 VD->VarDeclBits.ThreadSpecified = Record[Idx++];
906 VD->VarDeclBits.InitStyle = Record[Idx++];
907 VD->VarDeclBits.ExceptionVar = Record[Idx++];
908 VD->VarDeclBits.NRVOVariable = Record[Idx++];
909 VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
910 VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
911 VD->VarDeclBits.IsConstexpr = Record[Idx++];
913 // Only true variables (not parameters or implicit parameters) can be merged.
914 if (VD->getKind() == Decl::Var)
915 mergeRedeclarable(VD, Redecl);
917 if (uint64_t Val = Record[Idx++]) {
918 VD->setInit(Reader.ReadExpr(F));
920 EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
921 Eval->CheckedICE = true;
922 Eval->IsICE = Val == 3;
926 if (Record[Idx++]) { // HasMemberSpecializationInfo.
927 VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
928 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
929 SourceLocation POI = ReadSourceLocation(Record, Idx);
930 Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
934 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
938 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
940 unsigned isObjCMethodParam = Record[Idx++];
941 unsigned scopeDepth = Record[Idx++];
942 unsigned scopeIndex = Record[Idx++];
943 unsigned declQualifier = Record[Idx++];
944 if (isObjCMethodParam) {
945 assert(scopeDepth == 0);
946 PD->setObjCMethodScopeInfo(scopeIndex);
947 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
949 PD->setScopeInfo(scopeDepth, scopeIndex);
951 PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
952 PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
953 if (Record[Idx++]) // hasUninstantiatedDefaultArg.
954 PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
957 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
959 AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
960 AD->setRParenLoc(ReadSourceLocation(Record, Idx));
963 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
965 BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
966 BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
967 unsigned NumParams = Record[Idx++];
968 SmallVector<ParmVarDecl *, 16> Params;
969 Params.reserve(NumParams);
970 for (unsigned I = 0; I != NumParams; ++I)
971 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
972 BD->setParams(Params);
974 BD->setIsVariadic(Record[Idx++]);
975 BD->setBlockMissingReturnType(Record[Idx++]);
976 BD->setIsConversionFromLambda(Record[Idx++]);
978 bool capturesCXXThis = Record[Idx++];
979 unsigned numCaptures = Record[Idx++];
980 SmallVector<BlockDecl::Capture, 16> captures;
981 captures.reserve(numCaptures);
982 for (unsigned i = 0; i != numCaptures; ++i) {
983 VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
984 unsigned flags = Record[Idx++];
985 bool byRef = (flags & 1);
986 bool nested = (flags & 2);
987 Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0);
989 captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
991 BD->setCaptures(Reader.getContext(), captures.begin(),
992 captures.end(), capturesCXXThis);
995 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
997 D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
998 D->setExternLoc(ReadSourceLocation(Record, Idx));
999 D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1002 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1004 D->setLocStart(ReadSourceLocation(Record, Idx));
1008 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1009 RedeclarableResult Redecl = VisitRedeclarable(D);
1011 D->setInline(Record[Idx++]);
1012 D->LocStart = ReadSourceLocation(Record, Idx);
1013 D->RBraceLoc = ReadSourceLocation(Record, Idx);
1014 mergeRedeclarable(D, Redecl);
1016 if (Redecl.getFirstID() == ThisDeclID) {
1017 // Each module has its own anonymous namespace, which is disjoint from
1018 // any other module's anonymous namespaces, so don't attach the anonymous
1019 // namespace at all.
1020 NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1021 if (F.Kind != MK_Module)
1022 D->setAnonymousNamespace(Anon);
1024 // Link this namespace back to the first declaration, which has already
1025 // been deserialized.
1026 D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDeclaration());
1030 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1032 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1033 D->IdentLoc = ReadSourceLocation(Record, Idx);
1034 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1035 D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1038 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1040 D->setUsingLocation(ReadSourceLocation(Record, Idx));
1041 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1042 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1043 D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1044 D->setTypeName(Record[Idx++]);
1045 if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1046 Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1049 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1051 D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1052 D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1053 UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1055 Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1058 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1060 D->UsingLoc = ReadSourceLocation(Record, Idx);
1061 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1062 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1063 D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1064 D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1067 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1069 D->setUsingLoc(ReadSourceLocation(Record, Idx));
1070 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1071 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1074 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1075 UnresolvedUsingTypenameDecl *D) {
1077 D->TypenameLocation = ReadSourceLocation(Record, Idx);
1078 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1081 void ASTDeclReader::ReadCXXDefinitionData(
1082 struct CXXRecordDecl::DefinitionData &Data,
1083 const RecordData &Record, unsigned &Idx) {
1084 // Note: the caller has deserialized the IsLambda bit already.
1085 Data.UserDeclaredConstructor = Record[Idx++];
1086 Data.UserDeclaredCopyConstructor = Record[Idx++];
1087 Data.UserDeclaredMoveConstructor = Record[Idx++];
1088 Data.UserDeclaredCopyAssignment = Record[Idx++];
1089 Data.UserDeclaredMoveAssignment = Record[Idx++];
1090 Data.UserDeclaredDestructor = Record[Idx++];
1091 Data.Aggregate = Record[Idx++];
1092 Data.PlainOldData = Record[Idx++];
1093 Data.Empty = Record[Idx++];
1094 Data.Polymorphic = Record[Idx++];
1095 Data.Abstract = Record[Idx++];
1096 Data.IsStandardLayout = Record[Idx++];
1097 Data.HasNoNonEmptyBases = Record[Idx++];
1098 Data.HasPrivateFields = Record[Idx++];
1099 Data.HasProtectedFields = Record[Idx++];
1100 Data.HasPublicFields = Record[Idx++];
1101 Data.HasMutableFields = Record[Idx++];
1102 Data.HasOnlyCMembers = Record[Idx++];
1103 Data.HasInClassInitializer = Record[Idx++];
1104 Data.HasTrivialDefaultConstructor = Record[Idx++];
1105 Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1106 Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1107 Data.HasConstexprDefaultConstructor = Record[Idx++];
1108 Data.HasTrivialCopyConstructor = Record[Idx++];
1109 Data.HasTrivialMoveConstructor = Record[Idx++];
1110 Data.HasTrivialCopyAssignment = Record[Idx++];
1111 Data.HasTrivialMoveAssignment = Record[Idx++];
1112 Data.HasTrivialDestructor = Record[Idx++];
1113 Data.HasIrrelevantDestructor = Record[Idx++];
1114 Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1115 Data.ComputedVisibleConversions = Record[Idx++];
1116 Data.UserProvidedDefaultConstructor = Record[Idx++];
1117 Data.DeclaredDefaultConstructor = Record[Idx++];
1118 Data.DeclaredCopyConstructor = Record[Idx++];
1119 Data.DeclaredMoveConstructor = Record[Idx++];
1120 Data.DeclaredCopyAssignment = Record[Idx++];
1121 Data.DeclaredMoveAssignment = Record[Idx++];
1122 Data.DeclaredDestructor = Record[Idx++];
1123 Data.FailedImplicitMoveConstructor = Record[Idx++];
1124 Data.FailedImplicitMoveAssignment = Record[Idx++];
1126 Data.NumBases = Record[Idx++];
1128 Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1129 Data.NumVBases = Record[Idx++];
1131 Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1133 Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1134 Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1135 assert(Data.Definition && "Data.Definition should be already set!");
1136 Data.FirstFriend = ReadDeclAs<FriendDecl>(Record, Idx);
1138 if (Data.IsLambda) {
1139 typedef LambdaExpr::Capture Capture;
1140 CXXRecordDecl::LambdaDefinitionData &Lambda
1141 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1142 Lambda.Dependent = Record[Idx++];
1143 Lambda.NumCaptures = Record[Idx++];
1144 Lambda.NumExplicitCaptures = Record[Idx++];
1145 Lambda.ManglingNumber = Record[Idx++];
1146 Lambda.ContextDecl = ReadDecl(Record, Idx);
1148 = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1149 Capture *ToCapture = Lambda.Captures;
1150 Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1151 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1152 SourceLocation Loc = ReadSourceLocation(Record, Idx);
1153 bool IsImplicit = Record[Idx++];
1154 LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1155 VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1156 SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1157 *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1162 void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
1165 ASTContext &C = Reader.getContext();
1166 if (Record[Idx++]) {
1167 // Determine whether this is a lambda closure type, so that we can
1168 // allocate the appropriate DefinitionData structure.
1169 bool IsLambda = Record[Idx++];
1171 D->DefinitionData = new (C) CXXRecordDecl::LambdaDefinitionData(D, 0,
1174 D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
1176 // Propagate the DefinitionData pointer to the canonical declaration, so
1177 // that all other deserialized declarations will see it.
1178 // FIXME: Complain if there already is a DefinitionData!
1179 D->getCanonicalDecl()->DefinitionData = D->DefinitionData;
1181 ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
1183 // Note that we have deserialized a definition. Any declarations
1184 // deserialized before this one will be be given the DefinitionData pointer
1186 Reader.PendingDefinitions.insert(D);
1188 // Propagate DefinitionData pointer from the canonical declaration.
1189 D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1193 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1195 switch ((CXXRecKind)Record[Idx++]) {
1196 case CXXRecNotTemplate:
1198 case CXXRecTemplate:
1199 D->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1201 case CXXRecMemberSpecialization: {
1202 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1203 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1204 SourceLocation POI = ReadSourceLocation(Record, Idx);
1205 MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1206 MSI->setPointOfInstantiation(POI);
1207 D->TemplateOrInstantiation = MSI;
1212 // Load the key function to avoid deserializing every method so we can
1214 if (D->IsCompleteDefinition) {
1215 if (CXXMethodDecl *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1216 C.KeyFunctions[D] = Key;
1220 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1221 VisitFunctionDecl(D);
1222 unsigned NumOverridenMethods = Record[Idx++];
1223 while (NumOverridenMethods--) {
1224 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1225 // MD may be initializing.
1226 if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1227 Reader.getContext().addOverriddenMethod(D, MD);
1231 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1232 VisitCXXMethodDecl(D);
1234 D->IsExplicitSpecified = Record[Idx++];
1235 D->ImplicitlyDefined = Record[Idx++];
1236 llvm::tie(D->CtorInitializers, D->NumCtorInitializers)
1237 = Reader.ReadCXXCtorInitializers(F, Record, Idx);
1240 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1241 VisitCXXMethodDecl(D);
1243 D->ImplicitlyDefined = Record[Idx++];
1244 D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1247 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1248 VisitCXXMethodDecl(D);
1249 D->IsExplicitSpecified = Record[Idx++];
1252 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1254 D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1255 D->ImportedAndComplete.setInt(Record[Idx++]);
1256 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1257 for (unsigned I = 0, N = Record.back(); I != N; ++I)
1258 StoredLocs[I] = ReadSourceLocation(Record, Idx);
1259 ++Idx; // The number of stored source locations.
1262 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1264 D->setColonLoc(ReadSourceLocation(Record, Idx));
1267 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1270 D->Friend = GetTypeSourceInfo(Record, Idx);
1272 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1273 D->NextFriend = Record[Idx++];
1274 D->UnsupportedFriend = (Record[Idx++] != 0);
1275 D->FriendLoc = ReadSourceLocation(Record, Idx);
1278 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1280 unsigned NumParams = Record[Idx++];
1281 D->NumParams = NumParams;
1282 D->Params = new TemplateParameterList*[NumParams];
1283 for (unsigned i = 0; i != NumParams; ++i)
1284 D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1285 if (Record[Idx++]) // HasFriendDecl
1286 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1288 D->Friend = GetTypeSourceInfo(Record, Idx);
1289 D->FriendLoc = ReadSourceLocation(Record, Idx);
1292 void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1295 NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx);
1296 TemplateParameterList* TemplateParams
1297 = Reader.ReadTemplateParameterList(F, Record, Idx);
1298 D->init(TemplatedDecl, TemplateParams);
1301 ASTDeclReader::RedeclarableResult
1302 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1303 RedeclarableResult Redecl = VisitRedeclarable(D);
1305 // Make sure we've allocated the Common pointer first. We do this before
1306 // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1307 RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1308 if (!CanonD->Common) {
1309 CanonD->Common = CanonD->newCommon(Reader.getContext());
1310 Reader.PendingDefinitions.insert(CanonD);
1312 D->Common = CanonD->Common;
1314 // If this is the first declaration of the template, fill in the information
1315 // for the 'common' pointer.
1316 if (ThisDeclID == Redecl.getFirstID()) {
1317 if (RedeclarableTemplateDecl *RTD
1318 = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1319 assert(RTD->getKind() == D->getKind() &&
1320 "InstantiatedFromMemberTemplate kind mismatch");
1321 D->setInstantiatedFromMemberTemplate(RTD);
1323 D->setMemberSpecialization();
1327 VisitTemplateDecl(D);
1328 D->IdentifierNamespace = Record[Idx++];
1330 mergeRedeclarable(D, Redecl);
1335 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1336 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1338 if (ThisDeclID == Redecl.getFirstID()) {
1339 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1340 // the specializations.
1341 SmallVector<serialization::DeclID, 2> SpecIDs;
1342 SpecIDs.push_back(0);
1345 unsigned Size = Record[Idx++];
1347 for (unsigned I = 0; I != Size; ++I)
1348 SpecIDs.push_back(ReadDeclID(Record, Idx));
1350 // Partial specializations.
1351 Size = Record[Idx++];
1353 for (unsigned I = 0; I != Size; ++I)
1354 SpecIDs.push_back(ReadDeclID(Record, Idx));
1356 ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1358 typedef serialization::DeclID DeclID;
1360 // FIXME: Append specializations!
1361 CommonPtr->LazySpecializations
1362 = new (Reader.getContext()) DeclID [SpecIDs.size()];
1363 memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1364 SpecIDs.size() * sizeof(DeclID));
1367 CommonPtr->InjectedClassNameType = Reader.readType(F, Record, Idx);
1371 void ASTDeclReader::VisitClassTemplateSpecializationDecl(
1372 ClassTemplateSpecializationDecl *D) {
1373 VisitCXXRecordDecl(D);
1375 ASTContext &C = Reader.getContext();
1376 if (Decl *InstD = ReadDecl(Record, Idx)) {
1377 if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1378 D->SpecializedTemplate = CTD;
1380 SmallVector<TemplateArgument, 8> TemplArgs;
1381 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1382 TemplateArgumentList *ArgList
1383 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1385 ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1386 = new (C) ClassTemplateSpecializationDecl::
1387 SpecializedPartialSpecialization();
1388 PS->PartialSpecialization
1389 = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1390 PS->TemplateArgs = ArgList;
1391 D->SpecializedTemplate = PS;
1396 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1397 ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1398 = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1399 ExplicitInfo->TypeAsWritten = TyInfo;
1400 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1401 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1402 D->ExplicitInfo = ExplicitInfo;
1405 SmallVector<TemplateArgument, 8> TemplArgs;
1406 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1407 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1409 D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1410 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1412 bool writtenAsCanonicalDecl = Record[Idx++];
1413 if (writtenAsCanonicalDecl) {
1414 ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1415 if (D->isCanonicalDecl()) { // It's kept in the folding set.
1416 if (ClassTemplatePartialSpecializationDecl *Partial
1417 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1418 CanonPattern->getCommonPtr()->PartialSpecializations.GetOrInsertNode(Partial);
1420 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1426 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1427 ClassTemplatePartialSpecializationDecl *D) {
1428 VisitClassTemplateSpecializationDecl(D);
1430 ASTContext &C = Reader.getContext();
1431 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1433 unsigned NumArgs = Record[Idx++];
1435 D->NumArgsAsWritten = NumArgs;
1436 D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
1437 for (unsigned i=0; i != NumArgs; ++i)
1438 D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1441 D->SequenceNumber = Record[Idx++];
1443 // These are read/set from/to the first declaration.
1444 if (D->getPreviousDecl() == 0) {
1445 D->InstantiatedFromMember.setPointer(
1446 ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1447 D->InstantiatedFromMember.setInt(Record[Idx++]);
1451 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1452 ClassScopeFunctionSpecializationDecl *D) {
1454 D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1457 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1458 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1460 if (ThisDeclID == Redecl.getFirstID()) {
1461 // This FunctionTemplateDecl owns a CommonPtr; read it.
1463 // Read the function specialization declarations.
1464 // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
1465 // when reading the specialized FunctionDecl.
1466 unsigned NumSpecs = Record[Idx++];
1468 (void)ReadDecl(Record, Idx);
1472 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1475 D->setDeclaredWithTypename(Record[Idx++]);
1477 bool Inherited = Record[Idx++];
1478 TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1479 D->setDefaultArgument(DefArg, Inherited);
1482 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1483 VisitDeclaratorDecl(D);
1484 // TemplateParmPosition.
1485 D->setDepth(Record[Idx++]);
1486 D->setPosition(Record[Idx++]);
1487 if (D->isExpandedParameterPack()) {
1488 void **Data = reinterpret_cast<void **>(D + 1);
1489 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1490 Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1491 Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1494 // Rest of NonTypeTemplateParmDecl.
1495 D->ParameterPack = Record[Idx++];
1496 if (Record[Idx++]) {
1497 Expr *DefArg = Reader.ReadExpr(F);
1498 bool Inherited = Record[Idx++];
1499 D->setDefaultArgument(DefArg, Inherited);
1504 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1505 VisitTemplateDecl(D);
1506 // TemplateParmPosition.
1507 D->setDepth(Record[Idx++]);
1508 D->setPosition(Record[Idx++]);
1509 if (D->isExpandedParameterPack()) {
1510 void **Data = reinterpret_cast<void **>(D + 1);
1511 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1513 Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
1515 // Rest of TemplateTemplateParmDecl.
1516 TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1517 bool IsInherited = Record[Idx++];
1518 D->setDefaultArgument(Arg, IsInherited);
1519 D->ParameterPack = Record[Idx++];
1523 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1524 VisitRedeclarableTemplateDecl(D);
1527 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1529 D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
1530 D->AssertExprAndFailed.setInt(Record[Idx++]);
1531 D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
1532 D->RParenLoc = ReadSourceLocation(Record, Idx);
1535 std::pair<uint64_t, uint64_t>
1536 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1537 uint64_t LexicalOffset = Record[Idx++];
1538 uint64_t VisibleOffset = Record[Idx++];
1539 return std::make_pair(LexicalOffset, VisibleOffset);
1542 template <typename T>
1543 ASTDeclReader::RedeclarableResult
1544 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1545 DeclID FirstDeclID = ReadDeclID(Record, Idx);
1547 // 0 indicates that this declaration was the only declaration of its entity,
1548 // and is used for space optimization.
1549 if (FirstDeclID == 0)
1550 FirstDeclID = ThisDeclID;
1552 T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
1553 if (FirstDecl != D) {
1554 // We delay loading of the redeclaration chain to avoid deeply nested calls.
1555 // We temporarily set the first (canonical) declaration as the previous one
1556 // which is the one that matters and mark the real previous DeclID to be
1557 // loaded & attached later on.
1558 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
1561 // Note that this declaration has been deserialized.
1562 Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
1564 // The result structure takes care to note that we need to load the
1565 // other declaration chains for this ID.
1566 return RedeclarableResult(Reader, FirstDeclID);
1569 /// \brief Attempts to merge the given declaration (D) with another declaration
1570 /// of the same entity.
1571 template<typename T>
1572 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D,
1573 RedeclarableResult &Redecl) {
1574 // If modules are not available, there is no reason to perform this merge.
1575 if (!Reader.getContext().getLangOpts().Modules)
1578 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D))) {
1579 if (T *Existing = ExistingRes) {
1580 T *ExistingCanon = Existing->getCanonicalDecl();
1581 T *DCanon = static_cast<T*>(D)->getCanonicalDecl();
1582 if (ExistingCanon != DCanon) {
1583 // Have our redeclaration link point back at the canonical declaration
1584 // of the existing declaration, so that this declaration has the
1585 // appropriate canonical declaration.
1586 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
1588 // When we merge a namespace, update its pointer to the first namespace.
1589 if (NamespaceDecl *Namespace
1590 = dyn_cast<NamespaceDecl>(static_cast<T*>(D))) {
1591 Namespace->AnonOrFirstNamespaceAndInline.setPointer(
1592 static_cast<NamespaceDecl *>(static_cast<void*>(ExistingCanon)));
1595 // Don't introduce DCanon into the set of pending declaration chains.
1598 // Introduce ExistingCanon into the set of pending declaration chains,
1599 // if in fact it came from a module file.
1600 if (ExistingCanon->isFromASTFile()) {
1601 GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID();
1602 assert(ExistingCanonID && "Unrecorded canonical declaration ID?");
1603 if (Reader.PendingDeclChainsKnown.insert(ExistingCanonID))
1604 Reader.PendingDeclChains.push_back(ExistingCanonID);
1607 // If this declaration was the canonical declaration, make a note of
1608 // that. We accept the linear algorithm here because the number of
1609 // unique canonical declarations of an entity should always be tiny.
1610 if (DCanon == static_cast<T*>(D)) {
1611 SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
1612 if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
1614 Merged.push_back(Redecl.getFirstID());
1616 // If ExistingCanon did not come from a module file, introduce the
1617 // first declaration that *does* come from a module file to the
1618 // set of pending declaration chains, so that we merge this
1620 if (!ExistingCanon->isFromASTFile() &&
1621 Reader.PendingDeclChainsKnown.insert(Redecl.getFirstID()))
1622 Reader.PendingDeclChains.push_back(Merged[0]);
1629 //===----------------------------------------------------------------------===//
1630 // Attribute Reading
1631 //===----------------------------------------------------------------------===//
1633 /// \brief Reads attributes from the current stream position.
1634 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
1635 const RecordData &Record, unsigned &Idx) {
1636 for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
1638 attr::Kind Kind = (attr::Kind)Record[Idx++];
1639 SourceRange Range = ReadSourceRange(F, Record, Idx);
1641 #include "clang/Serialization/AttrPCHRead.inc"
1643 assert(New && "Unable to decode attribute?");
1644 Attrs.push_back(New);
1648 //===----------------------------------------------------------------------===//
1649 // ASTReader Implementation
1650 //===----------------------------------------------------------------------===//
1652 /// \brief Note that we have loaded the declaration with the given
1655 /// This routine notes that this declaration has already been loaded,
1656 /// so that future GetDecl calls will return this declaration rather
1657 /// than trying to load a new declaration.
1658 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
1659 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1660 DeclsLoaded[Index] = D;
1664 /// \brief Determine whether the consumer will be interested in seeing
1665 /// this declaration (via HandleTopLevelDecl).
1667 /// This routine should return true for anything that might affect
1668 /// code generation, e.g., inline function definitions, Objective-C
1669 /// declarations with metadata, etc.
1670 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
1671 // An ObjCMethodDecl is never considered as "interesting" because its
1672 // implementation container always is.
1674 if (isa<FileScopeAsmDecl>(D) ||
1675 isa<ObjCProtocolDecl>(D) ||
1676 isa<ObjCImplDecl>(D))
1678 if (VarDecl *Var = dyn_cast<VarDecl>(D))
1679 return Var->isFileVarDecl() &&
1680 Var->isThisDeclarationADefinition() == VarDecl::Definition;
1681 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1682 return Func->doesThisDeclarationHaveABody() || HasBody;
1687 /// \brief Get the correct cursor and offset for loading a declaration.
1688 ASTReader::RecordLocation
1689 ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
1690 // See if there's an override.
1691 DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1692 if (It != ReplacedDecls.end()) {
1693 RawLocation = It->second.RawLoc;
1694 return RecordLocation(It->second.Mod, It->second.Offset);
1697 GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
1698 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
1699 ModuleFile *M = I->second;
1701 DOffs = M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
1702 RawLocation = DOffs.Loc;
1703 return RecordLocation(M, DOffs.BitOffset);
1706 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
1707 ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
1708 = GlobalBitOffsetsMap.find(GlobalOffset);
1710 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
1711 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
1714 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
1715 return LocalOffset + M.GlobalBitOffset;
1718 /// \brief Determine whether the two declarations refer to the same entity.
1719 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
1720 assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
1725 // Must be in the same context.
1726 if (!X->getDeclContext()->getRedeclContext()->Equals(
1727 Y->getDeclContext()->getRedeclContext()))
1730 // Two typedefs refer to the same entity if they have the same underlying
1732 if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
1733 if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
1734 return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
1735 TypedefY->getUnderlyingType());
1737 // Must have the same kind.
1738 if (X->getKind() != Y->getKind())
1741 // Objective-C classes and protocols with the same name always match.
1742 if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
1745 // Compatible tags match.
1746 if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
1747 TagDecl *TagY = cast<TagDecl>(Y);
1748 return (TagX->getTagKind() == TagY->getTagKind()) ||
1749 ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
1750 TagX->getTagKind() == TTK_Interface) &&
1751 (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
1752 TagY->getTagKind() == TTK_Interface));
1755 // Functions with the same type and linkage match.
1756 // FIXME: This needs to cope with function templates, merging of
1757 //prototyped/non-prototyped functions, etc.
1758 if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
1759 FunctionDecl *FuncY = cast<FunctionDecl>(Y);
1760 return (FuncX->getLinkage() == FuncY->getLinkage()) &&
1761 FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
1764 // Variables with the same type and linkage match.
1765 if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
1766 VarDecl *VarY = cast<VarDecl>(Y);
1767 return (VarX->getLinkage() == VarY->getLinkage()) &&
1768 VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
1771 // Namespaces with the same name and inlinedness match.
1772 if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
1773 NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
1774 return NamespaceX->isInline() == NamespaceY->isInline();
1777 // Identical template names and kinds match.
1778 if (isa<TemplateDecl>(X))
1781 // FIXME: Many other cases to implement.
1785 ASTDeclReader::FindExistingResult::~FindExistingResult() {
1786 if (!AddResult || Existing)
1789 if (New->getDeclContext()->getRedeclContext()->isTranslationUnit()
1790 && Reader.SemaObj) {
1791 Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName());
1793 DeclContext *DC = New->getLexicalDeclContext();
1794 if (DC->isNamespace())
1799 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
1800 DeclarationName Name = D->getDeclName();
1802 // Don't bother trying to find unnamed declarations.
1803 FindExistingResult Result(Reader, D, /*Existing=*/0);
1808 DeclContext *DC = D->getDeclContext()->getRedeclContext();
1809 if (!DC->isFileContext())
1810 return FindExistingResult(Reader);
1812 if (DC->isTranslationUnit() && Reader.SemaObj) {
1813 IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
1814 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
1815 IEnd = IdResolver.end();
1817 if (isSameEntity(*I, D))
1818 return FindExistingResult(Reader, D, *I);
1822 if (DC->isNamespace()) {
1823 for (DeclContext::lookup_result R = DC->lookup(Name);
1824 R.first != R.second; ++R.first) {
1825 if (isSameEntity(*R.first, D))
1826 return FindExistingResult(Reader, D, *R.first);
1830 return FindExistingResult(Reader, D, /*Existing=*/0);
1833 void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) {
1834 assert(D && previous);
1835 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1836 TD->RedeclLink.setNext(cast<TagDecl>(previous));
1837 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1838 FD->RedeclLink.setNext(cast<FunctionDecl>(previous));
1839 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1840 VD->RedeclLink.setNext(cast<VarDecl>(previous));
1841 } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1842 TD->RedeclLink.setNext(cast<TypedefNameDecl>(previous));
1843 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1844 ID->RedeclLink.setNext(cast<ObjCInterfaceDecl>(previous));
1845 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1846 PD->RedeclLink.setNext(cast<ObjCProtocolDecl>(previous));
1847 } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1848 ND->RedeclLink.setNext(cast<NamespaceDecl>(previous));
1850 RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1851 TD->RedeclLink.setNext(cast<RedeclarableTemplateDecl>(previous));
1855 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
1856 assert(D && Latest);
1857 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1859 = Redeclarable<TagDecl>::LatestDeclLink(cast<TagDecl>(Latest));
1860 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1862 = Redeclarable<FunctionDecl>::LatestDeclLink(cast<FunctionDecl>(Latest));
1863 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1865 = Redeclarable<VarDecl>::LatestDeclLink(cast<VarDecl>(Latest));
1866 } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1868 = Redeclarable<TypedefNameDecl>::LatestDeclLink(
1869 cast<TypedefNameDecl>(Latest));
1870 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1872 = Redeclarable<ObjCInterfaceDecl>::LatestDeclLink(
1873 cast<ObjCInterfaceDecl>(Latest));
1874 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1876 = Redeclarable<ObjCProtocolDecl>::LatestDeclLink(
1877 cast<ObjCProtocolDecl>(Latest));
1878 } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1880 = Redeclarable<NamespaceDecl>::LatestDeclLink(
1881 cast<NamespaceDecl>(Latest));
1883 RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1885 = Redeclarable<RedeclarableTemplateDecl>::LatestDeclLink(
1886 cast<RedeclarableTemplateDecl>(Latest));
1890 ASTReader::MergedDeclsMap::iterator
1891 ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
1892 // If we don't have any stored merged declarations, just look in the
1893 // merged declarations set.
1894 StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
1895 if (StoredPos == StoredMergedDecls.end())
1896 return MergedDecls.find(Canon);
1898 // Append the stored merged declarations to the merged declarations set.
1899 MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
1900 if (Pos == MergedDecls.end())
1901 Pos = MergedDecls.insert(std::make_pair(Canon,
1902 SmallVector<DeclID, 2>())).first;
1903 Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
1904 StoredMergedDecls.erase(StoredPos);
1906 // Sort and uniquify the set of merged declarations.
1907 llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
1908 Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
1913 void ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) {
1914 Decl *previous = GetDecl(ID);
1915 ASTDeclReader::attachPreviousDecl(D, previous);
1918 /// \brief Read the declaration at the given offset from the AST file.
1919 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
1920 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
1921 unsigned RawLocation = 0;
1922 RecordLocation Loc = DeclCursorForID(ID, RawLocation);
1923 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
1924 // Keep track of where we are in the stream, then jump back there
1925 // after reading this declaration.
1926 SavedStreamPosition SavedPosition(DeclsCursor);
1928 ReadingKindTracker ReadingKind(Read_Decl, *this);
1930 // Note that we are loading a declaration record.
1931 Deserializing ADecl(this);
1933 DeclsCursor.JumpToBit(Loc.Offset);
1935 unsigned Code = DeclsCursor.ReadCode();
1937 ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
1940 switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
1941 case DECL_CONTEXT_LEXICAL:
1942 case DECL_CONTEXT_VISIBLE:
1943 llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
1945 D = TypedefDecl::CreateDeserialized(Context, ID);
1947 case DECL_TYPEALIAS:
1948 D = TypeAliasDecl::CreateDeserialized(Context, ID);
1951 D = EnumDecl::CreateDeserialized(Context, ID);
1954 D = RecordDecl::CreateDeserialized(Context, ID);
1956 case DECL_ENUM_CONSTANT:
1957 D = EnumConstantDecl::CreateDeserialized(Context, ID);
1960 D = FunctionDecl::CreateDeserialized(Context, ID);
1962 case DECL_LINKAGE_SPEC:
1963 D = LinkageSpecDecl::CreateDeserialized(Context, ID);
1966 D = LabelDecl::CreateDeserialized(Context, ID);
1968 case DECL_NAMESPACE:
1969 D = NamespaceDecl::CreateDeserialized(Context, ID);
1971 case DECL_NAMESPACE_ALIAS:
1972 D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
1975 D = UsingDecl::CreateDeserialized(Context, ID);
1977 case DECL_USING_SHADOW:
1978 D = UsingShadowDecl::CreateDeserialized(Context, ID);
1980 case DECL_USING_DIRECTIVE:
1981 D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
1983 case DECL_UNRESOLVED_USING_VALUE:
1984 D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
1986 case DECL_UNRESOLVED_USING_TYPENAME:
1987 D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
1989 case DECL_CXX_RECORD:
1990 D = CXXRecordDecl::CreateDeserialized(Context, ID);
1992 case DECL_CXX_METHOD:
1993 D = CXXMethodDecl::CreateDeserialized(Context, ID);
1995 case DECL_CXX_CONSTRUCTOR:
1996 D = CXXConstructorDecl::CreateDeserialized(Context, ID);
1998 case DECL_CXX_DESTRUCTOR:
1999 D = CXXDestructorDecl::CreateDeserialized(Context, ID);
2001 case DECL_CXX_CONVERSION:
2002 D = CXXConversionDecl::CreateDeserialized(Context, ID);
2004 case DECL_ACCESS_SPEC:
2005 D = AccessSpecDecl::CreateDeserialized(Context, ID);
2008 D = FriendDecl::CreateDeserialized(Context, ID);
2010 case DECL_FRIEND_TEMPLATE:
2011 D = FriendTemplateDecl::CreateDeserialized(Context, ID);
2013 case DECL_CLASS_TEMPLATE:
2014 D = ClassTemplateDecl::CreateDeserialized(Context, ID);
2016 case DECL_CLASS_TEMPLATE_SPECIALIZATION:
2017 D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2019 case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
2020 D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2022 case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
2023 D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
2025 case DECL_FUNCTION_TEMPLATE:
2026 D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
2028 case DECL_TEMPLATE_TYPE_PARM:
2029 D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
2031 case DECL_NON_TYPE_TEMPLATE_PARM:
2032 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
2034 case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
2035 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2037 case DECL_TEMPLATE_TEMPLATE_PARM:
2038 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
2040 case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
2041 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
2044 case DECL_TYPE_ALIAS_TEMPLATE:
2045 D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
2047 case DECL_STATIC_ASSERT:
2048 D = StaticAssertDecl::CreateDeserialized(Context, ID);
2050 case DECL_OBJC_METHOD:
2051 D = ObjCMethodDecl::CreateDeserialized(Context, ID);
2053 case DECL_OBJC_INTERFACE:
2054 D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
2056 case DECL_OBJC_IVAR:
2057 D = ObjCIvarDecl::CreateDeserialized(Context, ID);
2059 case DECL_OBJC_PROTOCOL:
2060 D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
2062 case DECL_OBJC_AT_DEFS_FIELD:
2063 D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
2065 case DECL_OBJC_CATEGORY:
2066 D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
2068 case DECL_OBJC_CATEGORY_IMPL:
2069 D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
2071 case DECL_OBJC_IMPLEMENTATION:
2072 D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
2074 case DECL_OBJC_COMPATIBLE_ALIAS:
2075 D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
2077 case DECL_OBJC_PROPERTY:
2078 D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
2080 case DECL_OBJC_PROPERTY_IMPL:
2081 D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
2084 D = FieldDecl::CreateDeserialized(Context, ID);
2086 case DECL_INDIRECTFIELD:
2087 D = IndirectFieldDecl::CreateDeserialized(Context, ID);
2090 D = VarDecl::CreateDeserialized(Context, ID);
2092 case DECL_IMPLICIT_PARAM:
2093 D = ImplicitParamDecl::CreateDeserialized(Context, ID);
2096 D = ParmVarDecl::CreateDeserialized(Context, ID);
2098 case DECL_FILE_SCOPE_ASM:
2099 D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
2102 D = BlockDecl::CreateDeserialized(Context, ID);
2104 case DECL_CXX_BASE_SPECIFIERS:
2105 Error("attempt to read a C++ base-specifier record as a declaration");
2108 // Note: last entry of the ImportDecl record is the number of stored source
2110 D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
2114 assert(D && "Unknown declaration reading AST file");
2115 LoadedDecl(Index, D);
2116 // Set the DeclContext before doing any deserialization, to make sure internal
2117 // calls to Decl::getASTContext() by Decl's methods will find the
2118 // TranslationUnitDecl without crashing.
2119 D->setDeclContext(Context.getTranslationUnitDecl());
2122 // If this declaration is also a declaration context, get the
2123 // offsets for its tables of lexical and visible declarations.
2124 if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
2125 std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
2126 if (Offsets.first || Offsets.second) {
2127 if (Offsets.first != 0)
2128 DC->setHasExternalLexicalStorage(true);
2129 if (Offsets.second != 0)
2130 DC->setHasExternalVisibleStorage(true);
2131 if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
2132 Loc.F->DeclContextInfos[DC]))
2136 // Now add the pending visible updates for this decl context, if it has any.
2137 DeclContextVisibleUpdatesPending::iterator I =
2138 PendingVisibleUpdates.find(ID);
2139 if (I != PendingVisibleUpdates.end()) {
2140 // There are updates. This means the context has external visible
2141 // storage, even if the original stored version didn't.
2142 DC->setHasExternalVisibleStorage(true);
2143 DeclContextVisibleUpdates &U = I->second;
2144 for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
2146 DeclContextInfo &Info = UI->second->DeclContextInfos[DC];
2147 delete Info.NameLookupTableData;
2148 Info.NameLookupTableData = UI->first;
2150 PendingVisibleUpdates.erase(I);
2153 if (!DC->hasExternalVisibleStorage() && DC->hasExternalLexicalStorage())
2154 DC->setMustBuildLookupTable();
2156 assert(Idx == Record.size());
2158 // Load any relevant update records.
2159 loadDeclUpdateRecords(ID, D);
2161 // Load the categories after recursive loading is finished.
2162 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
2163 if (Class->isThisDeclarationADefinition())
2164 loadObjCCategories(ID, Class);
2166 // If we have deserialized a declaration that has a definition the
2167 // AST consumer might need to know about, queue it.
2168 // We don't pass it to the consumer immediately because we may be in recursive
2169 // loading, and some declarations may still be initializing.
2170 if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
2171 InterestingDecls.push_back(D);
2176 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
2177 // The declaration may have been modified by files later in the chain.
2178 // If this is the case, read the record containing the updates from each file
2179 // and pass it to ASTDeclReader to make the modifications.
2180 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
2181 if (UpdI != DeclUpdateOffsets.end()) {
2182 FileOffsetsTy &UpdateOffsets = UpdI->second;
2183 for (FileOffsetsTy::iterator
2184 I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
2185 ModuleFile *F = I->first;
2186 uint64_t Offset = I->second;
2187 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
2188 SavedStreamPosition SavedPosition(Cursor);
2189 Cursor.JumpToBit(Offset);
2191 unsigned Code = Cursor.ReadCode();
2192 unsigned RecCode = Cursor.ReadRecord(Code, Record);
2194 assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
2197 ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
2198 Reader.UpdateDecl(D, *F, Record);
2204 struct CompareLocalRedeclarationsInfoToID {
2205 bool operator()(const LocalRedeclarationsInfo &X, DeclID Y) {
2206 return X.FirstID < Y;
2209 bool operator()(DeclID X, const LocalRedeclarationsInfo &Y) {
2210 return X < Y.FirstID;
2213 bool operator()(const LocalRedeclarationsInfo &X,
2214 const LocalRedeclarationsInfo &Y) {
2215 return X.FirstID < Y.FirstID;
2217 bool operator()(DeclID X, DeclID Y) {
2222 /// \brief Module visitor class that finds all of the redeclarations of a
2224 class RedeclChainVisitor {
2226 SmallVectorImpl<DeclID> &SearchDecls;
2227 llvm::SmallPtrSet<Decl *, 16> &Deserialized;
2228 GlobalDeclID CanonID;
2229 llvm::SmallVector<Decl *, 4> Chain;
2232 RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
2233 llvm::SmallPtrSet<Decl *, 16> &Deserialized,
2234 GlobalDeclID CanonID)
2235 : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
2237 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2238 addToChain(Reader.GetDecl(SearchDecls[I]));
2241 static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
2245 return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
2248 void addToChain(Decl *D) {
2252 if (Deserialized.erase(D))
2256 void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
2257 // Map global ID of the first declaration down to the local ID
2258 // used in this module file.
2259 DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
2263 // Perform a binary search to find the local redeclarations for this
2264 // declaration (if any).
2265 const LocalRedeclarationsInfo *Result
2266 = std::lower_bound(M.RedeclarationsMap,
2267 M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
2268 ID, CompareLocalRedeclarationsInfoToID());
2269 if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
2270 Result->FirstID != ID) {
2271 // If we have a previously-canonical singleton declaration that was
2272 // merged into another redeclaration chain, create a trivial chain
2273 // for this single declaration so that it will get wired into the
2274 // complete redeclaration chain.
2275 if (GlobalID != CanonID &&
2276 GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
2277 GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
2278 addToChain(Reader.GetDecl(GlobalID));
2284 // Dig out all of the redeclarations.
2285 unsigned Offset = Result->Offset;
2286 unsigned N = M.RedeclarationChains[Offset];
2287 M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
2288 for (unsigned I = 0; I != N; ++I)
2289 addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
2292 bool visit(ModuleFile &M) {
2293 // Visit each of the declarations.
2294 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2295 searchForID(M, SearchDecls[I]);
2299 ArrayRef<Decl *> getChain() const {
2305 void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
2306 Decl *D = GetDecl(ID);
2307 Decl *CanonDecl = D->getCanonicalDecl();
2309 // Determine the set of declaration IDs we'll be searching for.
2310 llvm::SmallVector<DeclID, 1> SearchDecls;
2311 GlobalDeclID CanonID = 0;
2312 if (D == CanonDecl) {
2313 SearchDecls.push_back(ID); // Always first.
2316 MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
2317 if (MergedPos != MergedDecls.end())
2318 SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
2320 // Build up the list of redeclarations.
2321 RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
2322 ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
2324 // Retrieve the chains.
2325 ArrayRef<Decl *> Chain = Visitor.getChain();
2329 // Hook up the chains.
2330 Decl *MostRecent = CanonDecl->getMostRecentDecl();
2331 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2332 if (Chain[I] == CanonDecl)
2335 ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent);
2336 MostRecent = Chain[I];
2339 ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
2343 struct CompareObjCCategoriesInfo {
2344 bool operator()(const ObjCCategoriesInfo &X, DeclID Y) {
2345 return X.DefinitionID < Y;
2348 bool operator()(DeclID X, const ObjCCategoriesInfo &Y) {
2349 return X < Y.DefinitionID;
2352 bool operator()(const ObjCCategoriesInfo &X,
2353 const ObjCCategoriesInfo &Y) {
2354 return X.DefinitionID < Y.DefinitionID;
2356 bool operator()(DeclID X, DeclID Y) {
2361 /// \brief Given an ObjC interface, goes through the modules and links to the
2362 /// interface all the categories for it.
2363 class ObjCCategoriesVisitor {
2365 serialization::GlobalDeclID InterfaceID;
2366 ObjCInterfaceDecl *Interface;
2367 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized;
2368 unsigned PreviousGeneration;
2369 ObjCCategoryDecl *Tail;
2370 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
2372 void add(ObjCCategoryDecl *Cat) {
2373 // Only process each category once.
2374 if (!Deserialized.erase(Cat))
2377 // Check for duplicate categories.
2378 if (Cat->getDeclName()) {
2379 ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
2381 Reader.getOwningModuleFile(Existing)
2382 != Reader.getOwningModuleFile(Cat)) {
2383 // FIXME: We should not warn for duplicates in diamond:
2391 // If there are duplicates in ML/MR, there will be warning when
2392 // creating MB *and* when importing MB. We should not warn when
2394 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
2395 << Interface->getDeclName() << Cat->getDeclName();
2396 Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
2397 } else if (!Existing) {
2398 // Record this category.
2403 // Add this category to the end of the chain.
2405 ASTDeclReader::setNextObjCCategory(Tail, Cat);
2407 Interface->setCategoryList(Cat);
2412 ObjCCategoriesVisitor(ASTReader &Reader,
2413 serialization::GlobalDeclID InterfaceID,
2414 ObjCInterfaceDecl *Interface,
2415 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized,
2416 unsigned PreviousGeneration)
2417 : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
2418 Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
2421 // Populate the name -> category map with the set of known categories.
2422 for (ObjCCategoryDecl *Cat = Interface->getCategoryList(); Cat;
2423 Cat = Cat->getNextClassCategory()) {
2424 if (Cat->getDeclName())
2425 NameCategoryMap[Cat->getDeclName()] = Cat;
2427 // Keep track of the tail of the category list.
2432 static bool visit(ModuleFile &M, void *UserData) {
2433 return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
2436 bool visit(ModuleFile &M) {
2437 // If we've loaded all of the category information we care about from
2438 // this module file, we're done.
2439 if (M.Generation <= PreviousGeneration)
2442 // Map global ID of the definition down to the local ID used in this
2443 // module file. If there is no such mapping, we'll find nothing here
2444 // (or in any module it imports).
2445 DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
2449 // Perform a binary search to find the local redeclarations for this
2450 // declaration (if any).
2451 const ObjCCategoriesInfo *Result
2452 = std::lower_bound(M.ObjCCategoriesMap,
2453 M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
2454 LocalID, CompareObjCCategoriesInfo());
2455 if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
2456 Result->DefinitionID != LocalID) {
2457 // We didn't find anything. If the class definition is in this module
2458 // file, then the module files it depends on cannot have any categories,
2459 // so suppress further lookup.
2460 return Reader.isDeclIDFromModule(InterfaceID, M);
2463 // We found something. Dig out all of the categories.
2464 unsigned Offset = Result->Offset;
2465 unsigned N = M.ObjCCategories[Offset];
2466 M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
2467 for (unsigned I = 0; I != N; ++I)
2468 add(cast_or_null<ObjCCategoryDecl>(
2469 Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
2475 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
2476 ObjCInterfaceDecl *D,
2477 unsigned PreviousGeneration) {
2478 ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
2479 PreviousGeneration);
2480 ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
2483 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
2484 const RecordData &Record) {
2486 while (Idx < Record.size()) {
2487 switch ((DeclUpdateKind)Record[Idx++]) {
2488 case UPD_CXX_ADDED_IMPLICIT_MEMBER:
2489 cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(ModuleFile, Record, Idx));
2492 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
2493 // It will be added to the template's specializations set when loaded.
2494 (void)Reader.ReadDecl(ModuleFile, Record, Idx);
2497 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
2499 = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
2501 // Each module has its own anonymous namespace, which is disjoint from
2502 // any other module's anonymous namespaces, so don't attach the anonymous
2503 // namespace at all.
2504 if (ModuleFile.Kind != MK_Module) {
2505 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
2506 TU->setAnonymousNamespace(Anon);
2508 cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
2513 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
2514 cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
2515 Reader.ReadSourceLocation(ModuleFile, Record, Idx));