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 "clang/Serialization/ASTReader.h"
16 #include "ASTCommon.h"
17 #include "ASTReaderInternals.h"
18 #include "clang/AST/ASTConsumer.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclGroup.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/DeclVisitor.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/Sema/IdentifierResolver.h"
26 #include "clang/Sema/Sema.h"
27 #include "clang/Sema/SemaDiagnostic.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;
49 uint64_t GetCurrentCursorOffset();
51 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
52 return Reader.ReadSourceLocation(F, R, I);
55 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
56 return Reader.ReadSourceRange(F, R, I);
59 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
60 return Reader.GetTypeSourceInfo(F, R, I);
63 serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
64 return Reader.ReadDeclID(F, R, I);
67 Decl *ReadDecl(const RecordData &R, unsigned &I) {
68 return Reader.ReadDecl(F, R, I);
72 T *ReadDeclAs(const RecordData &R, unsigned &I) {
73 return Reader.ReadDeclAs<T>(F, R, I);
76 void ReadQualifierInfo(QualifierInfo &Info,
77 const RecordData &R, unsigned &I) {
78 Reader.ReadQualifierInfo(F, Info, R, I);
81 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
82 const RecordData &R, unsigned &I) {
83 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
86 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
87 const RecordData &R, unsigned &I) {
88 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
91 serialization::SubmoduleID readSubmoduleID(const RecordData &R,
96 return Reader.getGlobalSubmoduleID(F, R[I++]);
99 Module *readModule(const RecordData &R, unsigned &I) {
100 return Reader.getSubmodule(readSubmoduleID(R, I));
103 void ReadCXXRecordDefinition(CXXRecordDecl *D);
104 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
105 const RecordData &R, unsigned &I);
106 void MergeDefinitionData(CXXRecordDecl *D,
107 struct CXXRecordDecl::DefinitionData &NewDD);
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 list of pending
114 /// redeclaration chains by calling \c suppress().
115 class RedeclarableResult {
117 GlobalDeclID FirstID;
121 void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION;
124 RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID,
126 : Reader(Reader), FirstID(FirstID), Owning(true), DeclKind(DeclKind) { }
128 RedeclarableResult(const RedeclarableResult &Other)
129 : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning) ,
130 DeclKind(Other.DeclKind)
132 Other.Owning = false;
135 ~RedeclarableResult() {
136 if (FirstID && Owning && isRedeclarableDeclKind(DeclKind) &&
137 Reader.PendingDeclChainsKnown.insert(FirstID))
138 Reader.PendingDeclChains.push_back(FirstID);
141 /// \brief Retrieve the first ID.
142 GlobalDeclID getFirstID() const { return FirstID; }
144 /// \brief Do not introduce this declaration ID into the set of pending
145 /// declaration chains.
151 /// \brief Class used to capture the result of searching for an existing
152 /// declaration of a specific kind and name, along with the ability
153 /// to update the place where this result was found (the declaration
154 /// chain hanging off an identifier or the DeclContext we searched in)
156 class FindExistingResult {
160 mutable bool AddResult;
162 void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION;
165 FindExistingResult(ASTReader &Reader)
166 : Reader(Reader), New(nullptr), Existing(nullptr), AddResult(false) {}
168 FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing)
169 : Reader(Reader), New(New), Existing(Existing), AddResult(true) { }
171 FindExistingResult(const FindExistingResult &Other)
172 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
173 AddResult(Other.AddResult)
175 Other.AddResult = false;
178 ~FindExistingResult();
180 /// \brief Suppress the addition of this result into the known set of
182 void suppress() { AddResult = false; }
184 operator NamedDecl*() const { return Existing; }
187 operator T*() const { return dyn_cast_or_null<T>(Existing); }
190 FindExistingResult findExisting(NamedDecl *D);
193 ASTDeclReader(ASTReader &Reader, ModuleFile &F,
195 unsigned RawLocation,
196 const RecordData &Record, unsigned &Idx)
197 : Reader(Reader), F(F), ThisDeclID(thisDeclID),
198 RawLocation(RawLocation), Record(Record), Idx(Idx),
199 TypeIDForTypeDecl(0), HasPendingBody(false) { }
201 template <typename DeclT>
202 static void attachPreviousDeclImpl(Redeclarable<DeclT> *D, Decl *Previous);
203 static void attachPreviousDeclImpl(...);
204 static void attachPreviousDecl(Decl *D, Decl *previous);
206 template <typename DeclT>
207 static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
208 static void attachLatestDeclImpl(...);
209 static void attachLatestDecl(Decl *D, Decl *latest);
211 template <typename DeclT>
212 static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
213 static void markIncompleteDeclChainImpl(...);
215 /// \brief Determine whether this declaration has a pending body.
216 bool hasPendingBody() const { return HasPendingBody; }
220 void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
221 const RecordData &Record);
223 static void setNextObjCCategory(ObjCCategoryDecl *Cat,
224 ObjCCategoryDecl *Next) {
225 Cat->NextClassCategory = Next;
228 void VisitDecl(Decl *D);
229 void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
230 void VisitNamedDecl(NamedDecl *ND);
231 void VisitLabelDecl(LabelDecl *LD);
232 void VisitNamespaceDecl(NamespaceDecl *D);
233 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
234 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
235 void VisitTypeDecl(TypeDecl *TD);
236 void VisitTypedefNameDecl(TypedefNameDecl *TD);
237 void VisitTypedefDecl(TypedefDecl *TD);
238 void VisitTypeAliasDecl(TypeAliasDecl *TD);
239 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
240 RedeclarableResult VisitTagDecl(TagDecl *TD);
241 void VisitEnumDecl(EnumDecl *ED);
242 RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
243 void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
244 RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
245 void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
246 RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
247 ClassTemplateSpecializationDecl *D);
248 void VisitClassTemplateSpecializationDecl(
249 ClassTemplateSpecializationDecl *D) {
250 VisitClassTemplateSpecializationDeclImpl(D);
252 void VisitClassTemplatePartialSpecializationDecl(
253 ClassTemplatePartialSpecializationDecl *D);
254 void VisitClassScopeFunctionSpecializationDecl(
255 ClassScopeFunctionSpecializationDecl *D);
257 VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
258 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
259 VisitVarTemplateSpecializationDeclImpl(D);
261 void VisitVarTemplatePartialSpecializationDecl(
262 VarTemplatePartialSpecializationDecl *D);
263 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
264 void VisitValueDecl(ValueDecl *VD);
265 void VisitEnumConstantDecl(EnumConstantDecl *ECD);
266 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
267 void VisitDeclaratorDecl(DeclaratorDecl *DD);
268 void VisitFunctionDecl(FunctionDecl *FD);
269 void VisitCXXMethodDecl(CXXMethodDecl *D);
270 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
271 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
272 void VisitCXXConversionDecl(CXXConversionDecl *D);
273 void VisitFieldDecl(FieldDecl *FD);
274 void VisitMSPropertyDecl(MSPropertyDecl *FD);
275 void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
276 RedeclarableResult VisitVarDeclImpl(VarDecl *D);
277 void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
278 void VisitImplicitParamDecl(ImplicitParamDecl *PD);
279 void VisitParmVarDecl(ParmVarDecl *PD);
280 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
281 DeclID VisitTemplateDecl(TemplateDecl *D);
282 RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
283 void VisitClassTemplateDecl(ClassTemplateDecl *D);
284 void VisitVarTemplateDecl(VarTemplateDecl *D);
285 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
286 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
287 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
288 void VisitUsingDecl(UsingDecl *D);
289 void VisitUsingShadowDecl(UsingShadowDecl *D);
290 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
291 void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
292 void VisitImportDecl(ImportDecl *D);
293 void VisitAccessSpecDecl(AccessSpecDecl *D);
294 void VisitFriendDecl(FriendDecl *D);
295 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
296 void VisitStaticAssertDecl(StaticAssertDecl *D);
297 void VisitBlockDecl(BlockDecl *BD);
298 void VisitCapturedDecl(CapturedDecl *CD);
299 void VisitEmptyDecl(EmptyDecl *D);
301 std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
304 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
307 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
308 DeclID TemplatePatternID = 0);
311 void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
312 RedeclarableResult &Redecl,
313 DeclID TemplatePatternID = 0);
316 void mergeMergeable(Mergeable<T> *D);
318 void mergeTemplatePattern(RedeclarableTemplateDecl *D,
319 RedeclarableTemplateDecl *Existing,
322 // FIXME: Reorder according to DeclNodes.td?
323 void VisitObjCMethodDecl(ObjCMethodDecl *D);
324 void VisitObjCContainerDecl(ObjCContainerDecl *D);
325 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
326 void VisitObjCIvarDecl(ObjCIvarDecl *D);
327 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
328 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
329 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
330 void VisitObjCImplDecl(ObjCImplDecl *D);
331 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
332 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
333 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
334 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
335 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
336 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
340 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
341 return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
344 void ASTDeclReader::Visit(Decl *D) {
345 DeclVisitor<ASTDeclReader, void>::Visit(D);
347 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
349 DeclaratorDecl::ExtInfo *Info =
350 DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
352 GetTypeSourceInfo(Record, Idx);
355 DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
359 if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
360 // We have a fully initialized TypeDecl. Read its type now.
361 TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
362 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
363 // if we have a fully initialized TypeDecl, we can safely read its type now.
364 ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
365 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
366 // FunctionDecl's body was written last after all other Stmts/Exprs.
367 // We only read it if FD doesn't already have a body (e.g., from another
369 // FIXME: Also consider = default and = delete.
370 // FIXME: Can we diagnose ODR violations somehow?
372 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
373 HasPendingBody = true;
378 void ASTDeclReader::VisitDecl(Decl *D) {
379 if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
380 isa<ParmVarDecl>(D)) {
381 // We don't want to deserialize the DeclContext of a template
382 // parameter or of a parameter of a function template immediately. These
383 // entities might be used in the formulation of its DeclContext (for
384 // example, a function parameter can be used in decltype() in trailing
385 // return type of the function). Use the translation unit DeclContext as a
387 GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
388 GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
389 Reader.addPendingDeclContextInfo(D,
390 SemaDCIDForTemplateParmDecl,
391 LexicalDCIDForTemplateParmDecl);
392 D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
394 DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
395 DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
396 DeclContext *MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
397 // Avoid calling setLexicalDeclContext() directly because it uses
398 // Decl::getASTContext() internally which is unsafe during derialization.
399 D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
400 Reader.getContext());
402 D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
403 D->setInvalidDecl(Record[Idx++]);
404 if (Record[Idx++]) { // hasAttrs
406 Reader.ReadAttributes(F, Attrs, Record, Idx);
407 // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
408 // internally which is unsafe during derialization.
409 D->setAttrsImpl(Attrs, Reader.getContext());
411 D->setImplicit(Record[Idx++]);
412 D->Used = Record[Idx++];
413 D->setReferenced(Record[Idx++]);
414 D->setTopLevelDeclInObjCContainer(Record[Idx++]);
415 D->setAccess((AccessSpecifier)Record[Idx++]);
416 D->FromASTFile = true;
417 D->setModulePrivate(Record[Idx++]);
418 D->Hidden = D->isModulePrivate();
420 // Determine whether this declaration is part of a (sub)module. If so, it
421 // may not yet be visible.
422 if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
423 // Store the owning submodule ID in the declaration.
424 D->setOwningModuleID(SubmoduleID);
426 // Module-private declarations are never visible, so there is no work to do.
427 if (!D->isModulePrivate()) {
428 if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
429 if (Owner->NameVisibility != Module::AllVisible) {
430 // The owning module is not visible. Mark this declaration as hidden.
433 // Note that this declaration was hidden because its owning module is
435 Reader.HiddenNamesMap[Owner].HiddenDecls.push_back(D);
442 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
443 llvm_unreachable("Translation units are not serialized");
446 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
448 ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
451 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
453 TD->setLocStart(ReadSourceLocation(Record, Idx));
454 // Delay type reading until after we have fully initialized the decl.
455 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
458 void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
459 RedeclarableResult Redecl = VisitRedeclarable(TD);
461 TypeSourceInfo *TInfo = GetTypeSourceInfo(Record, Idx);
462 if (Record[Idx++]) { // isModed
463 QualType modedT = Reader.readType(F, Record, Idx);
464 TD->setModedTypeSourceInfo(TInfo, modedT);
466 TD->setTypeSourceInfo(TInfo);
467 mergeRedeclarable(TD, Redecl);
470 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
471 VisitTypedefNameDecl(TD);
474 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
475 VisitTypedefNameDecl(TD);
478 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
479 RedeclarableResult Redecl = VisitRedeclarable(TD);
482 TD->IdentifierNamespace = Record[Idx++];
483 TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
484 TD->setCompleteDefinition(Record[Idx++]);
485 TD->setEmbeddedInDeclarator(Record[Idx++]);
486 TD->setFreeStanding(Record[Idx++]);
487 TD->setCompleteDefinitionRequired(Record[Idx++]);
488 TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
490 if (Record[Idx++]) { // hasExtInfo
491 TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
492 ReadQualifierInfo(*Info, Record, Idx);
493 TD->NamedDeclOrQualifier = Info;
495 TD->NamedDeclOrQualifier = ReadDeclAs<NamedDecl>(Record, Idx);
497 if (!isa<CXXRecordDecl>(TD))
498 mergeRedeclarable(TD, Redecl);
502 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
504 if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
505 ED->setIntegerTypeSourceInfo(TI);
507 ED->setIntegerType(Reader.readType(F, Record, Idx));
508 ED->setPromotionType(Reader.readType(F, Record, Idx));
509 ED->setNumPositiveBits(Record[Idx++]);
510 ED->setNumNegativeBits(Record[Idx++]);
511 ED->IsScoped = Record[Idx++];
512 ED->IsScopedUsingClassTag = Record[Idx++];
513 ED->IsFixed = Record[Idx++];
515 // If this is a definition subject to the ODR, and we already have a
516 // definition, merge this one into it.
517 if (ED->IsCompleteDefinition &&
518 Reader.getContext().getLangOpts().Modules &&
519 Reader.getContext().getLangOpts().CPlusPlus) {
520 if (EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()]) {
521 Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
522 ED->IsCompleteDefinition = false;
528 if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
529 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
530 SourceLocation POI = ReadSourceLocation(Record, Idx);
531 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
532 ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
536 ASTDeclReader::RedeclarableResult
537 ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
538 RedeclarableResult Redecl = VisitTagDecl(RD);
539 RD->setHasFlexibleArrayMember(Record[Idx++]);
540 RD->setAnonymousStructOrUnion(Record[Idx++]);
541 RD->setHasObjectMember(Record[Idx++]);
542 RD->setHasVolatileMember(Record[Idx++]);
546 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
548 VD->setType(Reader.readType(F, Record, Idx));
551 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
554 ECD->setInitExpr(Reader.ReadExpr(F));
555 ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
559 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
561 DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
562 if (Record[Idx++]) { // hasExtInfo
563 DeclaratorDecl::ExtInfo *Info
564 = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
565 ReadQualifierInfo(*Info, Record, Idx);
570 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
571 RedeclarableResult Redecl = VisitRedeclarable(FD);
572 VisitDeclaratorDecl(FD);
574 ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
575 FD->IdentifierNamespace = Record[Idx++];
577 // FunctionDecl's body is handled last at ASTDeclReader::Visit,
578 // after everything else is read.
580 FD->SClass = (StorageClass)Record[Idx++];
581 FD->IsInline = Record[Idx++];
582 FD->IsInlineSpecified = Record[Idx++];
583 FD->IsVirtualAsWritten = Record[Idx++];
584 FD->IsPure = Record[Idx++];
585 FD->HasInheritedPrototype = Record[Idx++];
586 FD->HasWrittenPrototype = Record[Idx++];
587 FD->IsDeleted = Record[Idx++];
588 FD->IsTrivial = Record[Idx++];
589 FD->IsDefaulted = Record[Idx++];
590 FD->IsExplicitlyDefaulted = Record[Idx++];
591 FD->HasImplicitReturnZero = Record[Idx++];
592 FD->IsConstexpr = Record[Idx++];
593 FD->HasSkippedBody = Record[Idx++];
594 FD->IsLateTemplateParsed = Record[Idx++];
595 FD->setCachedLinkage(Linkage(Record[Idx++]));
596 FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
598 switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
599 case FunctionDecl::TK_NonTemplate:
600 mergeRedeclarable(FD, Redecl);
602 case FunctionDecl::TK_FunctionTemplate:
603 // Merged when we merge the template.
604 FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
607 case FunctionDecl::TK_MemberSpecialization: {
608 FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
609 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
610 SourceLocation POI = ReadSourceLocation(Record, Idx);
611 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
612 FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
613 mergeRedeclarable(FD, Redecl);
616 case FunctionDecl::TK_FunctionTemplateSpecialization: {
617 FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
619 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
621 // Template arguments.
622 SmallVector<TemplateArgument, 8> TemplArgs;
623 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
625 // Template args as written.
626 SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
627 SourceLocation LAngleLoc, RAngleLoc;
628 bool HasTemplateArgumentsAsWritten = Record[Idx++];
629 if (HasTemplateArgumentsAsWritten) {
630 unsigned NumTemplateArgLocs = Record[Idx++];
631 TemplArgLocs.reserve(NumTemplateArgLocs);
632 for (unsigned i=0; i != NumTemplateArgLocs; ++i)
633 TemplArgLocs.push_back(
634 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
636 LAngleLoc = ReadSourceLocation(Record, Idx);
637 RAngleLoc = ReadSourceLocation(Record, Idx);
640 SourceLocation POI = ReadSourceLocation(Record, Idx);
642 ASTContext &C = Reader.getContext();
643 TemplateArgumentList *TemplArgList
644 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
645 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
646 for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
647 TemplArgsInfo.addArgument(TemplArgLocs[i]);
648 FunctionTemplateSpecializationInfo *FTInfo
649 = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
651 HasTemplateArgumentsAsWritten ? &TemplArgsInfo
654 FD->TemplateOrSpecialization = FTInfo;
656 if (FD->isCanonicalDecl()) { // if canonical add to template's set.
657 // The template that contains the specializations set. It's not safe to
658 // use getCanonicalDecl on Template since it may still be initializing.
659 FunctionTemplateDecl *CanonTemplate
660 = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
661 // Get the InsertPos by FindNodeOrInsertPos() instead of calling
662 // InsertNode(FTInfo) directly to avoid the getASTContext() call in
663 // FunctionTemplateSpecializationInfo's Profile().
664 // We avoid getASTContext because a decl in the parent hierarchy may
666 llvm::FoldingSetNodeID ID;
667 FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C);
668 void *InsertPos = nullptr;
669 FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
670 CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
672 CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
674 assert(Reader.getContext().getLangOpts().Modules &&
675 "already deserialized this template specialization");
676 // FIXME: This specialization is a redeclaration of one from another
682 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
684 UnresolvedSet<8> TemplDecls;
685 unsigned NumTemplates = Record[Idx++];
686 while (NumTemplates--)
687 TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
690 TemplateArgumentListInfo TemplArgs;
691 unsigned NumArgs = Record[Idx++];
693 TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
694 TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
695 TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
697 FD->setDependentTemplateSpecialization(Reader.getContext(),
698 TemplDecls, TemplArgs);
705 // Read in the parameters.
706 unsigned NumParams = Record[Idx++];
707 SmallVector<ParmVarDecl *, 16> Params;
708 Params.reserve(NumParams);
709 for (unsigned I = 0; I != NumParams; ++I)
710 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
711 FD->setParams(Reader.getContext(), Params);
714 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
717 // Load the body on-demand. Most clients won't care, because method
718 // definitions rarely show up in headers.
719 Reader.PendingBodies[MD] = GetCurrentCursorOffset();
720 HasPendingBody = true;
721 MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
722 MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
724 MD->setInstanceMethod(Record[Idx++]);
725 MD->setVariadic(Record[Idx++]);
726 MD->setPropertyAccessor(Record[Idx++]);
727 MD->setDefined(Record[Idx++]);
728 MD->IsOverriding = Record[Idx++];
729 MD->HasSkippedBody = Record[Idx++];
731 MD->IsRedeclaration = Record[Idx++];
732 MD->HasRedeclaration = Record[Idx++];
733 if (MD->HasRedeclaration)
734 Reader.getContext().setObjCMethodRedeclaration(MD,
735 ReadDeclAs<ObjCMethodDecl>(Record, Idx));
737 MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
738 MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
739 MD->SetRelatedResultType(Record[Idx++]);
740 MD->setReturnType(Reader.readType(F, Record, Idx));
741 MD->setReturnTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
742 MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
743 unsigned NumParams = Record[Idx++];
744 SmallVector<ParmVarDecl *, 16> Params;
745 Params.reserve(NumParams);
746 for (unsigned I = 0; I != NumParams; ++I)
747 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
749 MD->SelLocsKind = Record[Idx++];
750 unsigned NumStoredSelLocs = Record[Idx++];
751 SmallVector<SourceLocation, 16> SelLocs;
752 SelLocs.reserve(NumStoredSelLocs);
753 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
754 SelLocs.push_back(ReadSourceLocation(Record, Idx));
756 MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
759 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
761 CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
762 CD->setAtEndRange(ReadSourceRange(Record, Idx));
765 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
766 RedeclarableResult Redecl = VisitRedeclarable(ID);
767 VisitObjCContainerDecl(ID);
768 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
769 mergeRedeclarable(ID, Redecl);
772 // Read the definition.
773 ID->allocateDefinitionData();
775 // Set the definition data of the canonical declaration, so other
776 // redeclarations will see it.
777 ID->getCanonicalDecl()->Data = ID->Data;
779 ObjCInterfaceDecl::DefinitionData &Data = ID->data();
781 // Read the superclass.
782 Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
783 Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
785 Data.EndLoc = ReadSourceLocation(Record, Idx);
786 Data.HasDesignatedInitializers = Record[Idx++];
788 // Read the directly referenced protocols and their SourceLocations.
789 unsigned NumProtocols = Record[Idx++];
790 SmallVector<ObjCProtocolDecl *, 16> Protocols;
791 Protocols.reserve(NumProtocols);
792 for (unsigned I = 0; I != NumProtocols; ++I)
793 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
794 SmallVector<SourceLocation, 16> ProtoLocs;
795 ProtoLocs.reserve(NumProtocols);
796 for (unsigned I = 0; I != NumProtocols; ++I)
797 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
798 ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
799 Reader.getContext());
801 // Read the transitive closure of protocols referenced by this class.
802 NumProtocols = Record[Idx++];
804 Protocols.reserve(NumProtocols);
805 for (unsigned I = 0; I != NumProtocols; ++I)
806 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
807 ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
808 Reader.getContext());
810 // We will rebuild this list lazily.
811 ID->setIvarList(nullptr);
813 // Note that we have deserialized a definition.
814 Reader.PendingDefinitions.insert(ID);
816 // Note that we've loaded this Objective-C class.
817 Reader.ObjCClassesLoaded.push_back(ID);
819 ID->Data = ID->getCanonicalDecl()->Data;
823 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
825 IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
826 // This field will be built lazily.
827 IVD->setNextIvar(nullptr);
828 bool synth = Record[Idx++];
829 IVD->setSynthesize(synth);
832 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
833 RedeclarableResult Redecl = VisitRedeclarable(PD);
834 VisitObjCContainerDecl(PD);
835 mergeRedeclarable(PD, Redecl);
838 // Read the definition.
839 PD->allocateDefinitionData();
841 // Set the definition data of the canonical declaration, so other
842 // redeclarations will see it.
843 PD->getCanonicalDecl()->Data = PD->Data;
845 unsigned NumProtoRefs = Record[Idx++];
846 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
847 ProtoRefs.reserve(NumProtoRefs);
848 for (unsigned I = 0; I != NumProtoRefs; ++I)
849 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
850 SmallVector<SourceLocation, 16> ProtoLocs;
851 ProtoLocs.reserve(NumProtoRefs);
852 for (unsigned I = 0; I != NumProtoRefs; ++I)
853 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
854 PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
855 Reader.getContext());
857 // Note that we have deserialized a definition.
858 Reader.PendingDefinitions.insert(PD);
860 PD->Data = PD->getCanonicalDecl()->Data;
864 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
868 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
869 VisitObjCContainerDecl(CD);
870 CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
871 CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
872 CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
874 // Note that this category has been deserialized. We do this before
875 // deserializing the interface declaration, so that it will consider this
877 Reader.CategoriesDeserialized.insert(CD);
879 CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
880 unsigned NumProtoRefs = Record[Idx++];
881 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
882 ProtoRefs.reserve(NumProtoRefs);
883 for (unsigned I = 0; I != NumProtoRefs; ++I)
884 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
885 SmallVector<SourceLocation, 16> ProtoLocs;
886 ProtoLocs.reserve(NumProtoRefs);
887 for (unsigned I = 0; I != NumProtoRefs; ++I)
888 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
889 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
890 Reader.getContext());
893 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
895 CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
898 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
900 D->setAtLoc(ReadSourceLocation(Record, Idx));
901 D->setLParenLoc(ReadSourceLocation(Record, Idx));
902 D->setType(GetTypeSourceInfo(Record, Idx));
903 // FIXME: stable encoding
904 D->setPropertyAttributes(
905 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
906 D->setPropertyAttributesAsWritten(
907 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
908 // FIXME: stable encoding
909 D->setPropertyImplementation(
910 (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
911 D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
912 D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
913 D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
914 D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
915 D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
918 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
919 VisitObjCContainerDecl(D);
920 D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
923 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
924 VisitObjCImplDecl(D);
925 D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
926 D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
929 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
930 VisitObjCImplDecl(D);
931 D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
932 D->SuperLoc = ReadSourceLocation(Record, Idx);
933 D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
934 D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
935 D->setHasNonZeroConstructors(Record[Idx++]);
936 D->setHasDestructors(Record[Idx++]);
937 std::tie(D->IvarInitializers, D->NumIvarInitializers) =
938 Reader.ReadCXXCtorInitializers(F, Record, Idx);
942 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
944 D->setAtLoc(ReadSourceLocation(Record, Idx));
945 D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
946 D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
947 D->IvarLoc = ReadSourceLocation(Record, Idx);
948 D->setGetterCXXConstructor(Reader.ReadExpr(F));
949 D->setSetterCXXAssignment(Reader.ReadExpr(F));
952 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
953 VisitDeclaratorDecl(FD);
954 FD->Mutable = Record[Idx++];
955 if (int BitWidthOrInitializer = Record[Idx++]) {
956 FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1);
957 FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F));
959 if (!FD->getDeclName()) {
960 if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
961 Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
966 void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
967 VisitDeclaratorDecl(PD);
968 PD->GetterId = Reader.GetIdentifierInfo(F, Record, Idx);
969 PD->SetterId = Reader.GetIdentifierInfo(F, Record, Idx);
972 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
975 FD->ChainingSize = Record[Idx++];
976 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
977 FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
979 for (unsigned I = 0; I != FD->ChainingSize; ++I)
980 FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
983 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
984 RedeclarableResult Redecl = VisitRedeclarable(VD);
985 VisitDeclaratorDecl(VD);
987 VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
988 VD->VarDeclBits.TSCSpec = Record[Idx++];
989 VD->VarDeclBits.InitStyle = Record[Idx++];
990 VD->VarDeclBits.ExceptionVar = Record[Idx++];
991 VD->VarDeclBits.NRVOVariable = Record[Idx++];
992 VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
993 VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
994 VD->VarDeclBits.IsConstexpr = Record[Idx++];
995 VD->VarDeclBits.IsInitCapture = Record[Idx++];
996 VD->VarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
997 Linkage VarLinkage = Linkage(Record[Idx++]);
998 VD->setCachedLinkage(VarLinkage);
1000 // Reconstruct the one piece of the IdentifierNamespace that we need.
1001 if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
1002 VD->getLexicalDeclContext()->isFunctionOrMethod())
1003 VD->setLocalExternDecl();
1005 if (uint64_t Val = Record[Idx++]) {
1006 VD->setInit(Reader.ReadExpr(F));
1008 EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1009 Eval->CheckedICE = true;
1010 Eval->IsICE = Val == 3;
1015 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1017 switch ((VarKind)Record[Idx++]) {
1018 case VarNotTemplate:
1019 // Only true variables (not parameters or implicit parameters) can be merged
1020 if (VD->getKind() != Decl::ParmVar && VD->getKind() != Decl::ImplicitParam &&
1021 !isa<VarTemplateSpecializationDecl>(VD))
1022 mergeRedeclarable(VD, Redecl);
1025 // Merged when we merge the template.
1026 VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
1028 case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
1029 VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
1030 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1031 SourceLocation POI = ReadSourceLocation(Record, Idx);
1032 Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
1033 mergeRedeclarable(VD, Redecl);
1041 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
1045 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
1047 unsigned isObjCMethodParam = Record[Idx++];
1048 unsigned scopeDepth = Record[Idx++];
1049 unsigned scopeIndex = Record[Idx++];
1050 unsigned declQualifier = Record[Idx++];
1051 if (isObjCMethodParam) {
1052 assert(scopeDepth == 0);
1053 PD->setObjCMethodScopeInfo(scopeIndex);
1054 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1056 PD->setScopeInfo(scopeDepth, scopeIndex);
1058 PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
1059 PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
1060 if (Record[Idx++]) // hasUninstantiatedDefaultArg.
1061 PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
1063 // FIXME: If this is a redeclaration of a function from another module, handle
1064 // inheritance of default arguments.
1067 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
1069 AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
1070 AD->setRParenLoc(ReadSourceLocation(Record, Idx));
1073 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
1075 BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
1076 BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
1077 unsigned NumParams = Record[Idx++];
1078 SmallVector<ParmVarDecl *, 16> Params;
1079 Params.reserve(NumParams);
1080 for (unsigned I = 0; I != NumParams; ++I)
1081 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
1082 BD->setParams(Params);
1084 BD->setIsVariadic(Record[Idx++]);
1085 BD->setBlockMissingReturnType(Record[Idx++]);
1086 BD->setIsConversionFromLambda(Record[Idx++]);
1088 bool capturesCXXThis = Record[Idx++];
1089 unsigned numCaptures = Record[Idx++];
1090 SmallVector<BlockDecl::Capture, 16> captures;
1091 captures.reserve(numCaptures);
1092 for (unsigned i = 0; i != numCaptures; ++i) {
1093 VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
1094 unsigned flags = Record[Idx++];
1095 bool byRef = (flags & 1);
1096 bool nested = (flags & 2);
1097 Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr);
1099 captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
1101 BD->setCaptures(Reader.getContext(), captures.begin(),
1102 captures.end(), capturesCXXThis);
1105 void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
1107 unsigned ContextParamPos = Record[Idx++];
1108 CD->setNothrow(Record[Idx++] != 0);
1109 // Body is set by VisitCapturedStmt.
1110 for (unsigned I = 0; I < CD->NumParams; ++I) {
1111 if (I != ContextParamPos)
1112 CD->setParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1114 CD->setContextParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1118 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1120 D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
1121 D->setExternLoc(ReadSourceLocation(Record, Idx));
1122 D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1125 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1127 D->setLocStart(ReadSourceLocation(Record, Idx));
1131 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1132 RedeclarableResult Redecl = VisitRedeclarable(D);
1134 D->setInline(Record[Idx++]);
1135 D->LocStart = ReadSourceLocation(Record, Idx);
1136 D->RBraceLoc = ReadSourceLocation(Record, Idx);
1138 if (Redecl.getFirstID() == ThisDeclID) {
1139 // Each module has its own anonymous namespace, which is disjoint from
1140 // any other module's anonymous namespaces, so don't attach the anonymous
1141 // namespace at all.
1142 NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1143 if (F.Kind != MK_Module)
1144 D->setAnonymousNamespace(Anon);
1146 // Link this namespace back to the first declaration, which has already
1147 // been deserialized.
1148 D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
1151 mergeRedeclarable(D, Redecl);
1154 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1156 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1157 D->IdentLoc = ReadSourceLocation(Record, Idx);
1158 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1159 D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1162 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1164 D->setUsingLoc(ReadSourceLocation(Record, Idx));
1165 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1166 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1167 D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1168 D->setTypename(Record[Idx++]);
1169 if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1170 Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1173 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1174 RedeclarableResult Redecl = VisitRedeclarable(D);
1176 D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1177 D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1178 UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1180 Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1181 mergeRedeclarable(D, Redecl);
1184 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1186 D->UsingLoc = ReadSourceLocation(Record, Idx);
1187 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1188 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1189 D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1190 D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1193 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1195 D->setUsingLoc(ReadSourceLocation(Record, Idx));
1196 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1197 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1200 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1201 UnresolvedUsingTypenameDecl *D) {
1203 D->TypenameLocation = ReadSourceLocation(Record, Idx);
1204 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1207 void ASTDeclReader::ReadCXXDefinitionData(
1208 struct CXXRecordDecl::DefinitionData &Data,
1209 const RecordData &Record, unsigned &Idx) {
1210 // Note: the caller has deserialized the IsLambda bit already.
1211 Data.UserDeclaredConstructor = Record[Idx++];
1212 Data.UserDeclaredSpecialMembers = Record[Idx++];
1213 Data.Aggregate = Record[Idx++];
1214 Data.PlainOldData = Record[Idx++];
1215 Data.Empty = Record[Idx++];
1216 Data.Polymorphic = Record[Idx++];
1217 Data.Abstract = Record[Idx++];
1218 Data.IsStandardLayout = Record[Idx++];
1219 Data.HasNoNonEmptyBases = Record[Idx++];
1220 Data.HasPrivateFields = Record[Idx++];
1221 Data.HasProtectedFields = Record[Idx++];
1222 Data.HasPublicFields = Record[Idx++];
1223 Data.HasMutableFields = Record[Idx++];
1224 Data.HasVariantMembers = Record[Idx++];
1225 Data.HasOnlyCMembers = Record[Idx++];
1226 Data.HasInClassInitializer = Record[Idx++];
1227 Data.HasUninitializedReferenceMember = Record[Idx++];
1228 Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
1229 Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
1230 Data.NeedOverloadResolutionForDestructor = Record[Idx++];
1231 Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
1232 Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
1233 Data.DefaultedDestructorIsDeleted = Record[Idx++];
1234 Data.HasTrivialSpecialMembers = Record[Idx++];
1235 Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
1236 Data.HasIrrelevantDestructor = Record[Idx++];
1237 Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1238 Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1239 Data.HasConstexprDefaultConstructor = Record[Idx++];
1240 Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1241 Data.ComputedVisibleConversions = Record[Idx++];
1242 Data.UserProvidedDefaultConstructor = Record[Idx++];
1243 Data.DeclaredSpecialMembers = Record[Idx++];
1244 Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
1245 Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
1246 Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
1247 Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
1249 Data.NumBases = Record[Idx++];
1251 Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1252 Data.NumVBases = Record[Idx++];
1254 Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1256 Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1257 Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1258 assert(Data.Definition && "Data.Definition should be already set!");
1259 Data.FirstFriend = ReadDeclID(Record, Idx);
1261 if (Data.IsLambda) {
1262 typedef LambdaCapture Capture;
1263 CXXRecordDecl::LambdaDefinitionData &Lambda
1264 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1265 Lambda.Dependent = Record[Idx++];
1266 Lambda.IsGenericLambda = Record[Idx++];
1267 Lambda.CaptureDefault = Record[Idx++];
1268 Lambda.NumCaptures = Record[Idx++];
1269 Lambda.NumExplicitCaptures = Record[Idx++];
1270 Lambda.ManglingNumber = Record[Idx++];
1271 Lambda.ContextDecl = ReadDecl(Record, Idx);
1273 = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1274 Capture *ToCapture = Lambda.Captures;
1275 Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1276 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1277 SourceLocation Loc = ReadSourceLocation(Record, Idx);
1278 bool IsImplicit = Record[Idx++];
1279 LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1282 *ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
1286 VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1287 SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1288 *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1295 void ASTDeclReader::MergeDefinitionData(
1296 CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &MergeDD) {
1297 assert(D->DefinitionData.getNotUpdated() &&
1298 "merging class definition into non-definition");
1299 auto &DD = *D->DefinitionData.getNotUpdated();
1301 // If the new definition has new special members, let the name lookup
1302 // code know that it needs to look in the new definition too.
1303 if ((MergeDD.DeclaredSpecialMembers & ~DD.DeclaredSpecialMembers) &&
1304 DD.Definition != MergeDD.Definition) {
1305 Reader.MergedLookups[DD.Definition].push_back(MergeDD.Definition);
1306 DD.Definition->setHasExternalVisibleStorage();
1309 // FIXME: Move this out into a .def file?
1310 // FIXME: Issue a diagnostic on a mismatched MATCH_FIELD, rather than
1311 // asserting; this can happen in the case of an ODR violation.
1312 bool DetectedOdrViolation = false;
1313 #define OR_FIELD(Field) DD.Field |= MergeDD.Field;
1314 #define MATCH_FIELD(Field) \
1315 DetectedOdrViolation |= DD.Field != MergeDD.Field; \
1317 MATCH_FIELD(UserDeclaredConstructor)
1318 MATCH_FIELD(UserDeclaredSpecialMembers)
1319 MATCH_FIELD(Aggregate)
1320 MATCH_FIELD(PlainOldData)
1322 MATCH_FIELD(Polymorphic)
1323 MATCH_FIELD(Abstract)
1324 MATCH_FIELD(IsStandardLayout)
1325 MATCH_FIELD(HasNoNonEmptyBases)
1326 MATCH_FIELD(HasPrivateFields)
1327 MATCH_FIELD(HasProtectedFields)
1328 MATCH_FIELD(HasPublicFields)
1329 MATCH_FIELD(HasMutableFields)
1330 MATCH_FIELD(HasVariantMembers)
1331 MATCH_FIELD(HasOnlyCMembers)
1332 MATCH_FIELD(HasInClassInitializer)
1333 MATCH_FIELD(HasUninitializedReferenceMember)
1334 MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
1335 MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
1336 MATCH_FIELD(NeedOverloadResolutionForDestructor)
1337 MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
1338 MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
1339 MATCH_FIELD(DefaultedDestructorIsDeleted)
1340 OR_FIELD(HasTrivialSpecialMembers)
1341 OR_FIELD(DeclaredNonTrivialSpecialMembers)
1342 MATCH_FIELD(HasIrrelevantDestructor)
1343 OR_FIELD(HasConstexprNonCopyMoveConstructor)
1344 MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
1345 OR_FIELD(HasConstexprDefaultConstructor)
1346 MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
1347 // ComputedVisibleConversions is handled below.
1348 MATCH_FIELD(UserProvidedDefaultConstructor)
1349 OR_FIELD(DeclaredSpecialMembers)
1350 MATCH_FIELD(ImplicitCopyConstructorHasConstParam)
1351 MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
1352 OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
1353 OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
1354 MATCH_FIELD(IsLambda)
1358 if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
1359 DetectedOdrViolation = true;
1360 // FIXME: Issue a diagnostic if the base classes don't match when we come
1361 // to lazily load them.
1363 // FIXME: Issue a diagnostic if the list of conversion functions doesn't
1364 // match when we come to lazily load them.
1365 if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
1366 DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
1367 DD.ComputedVisibleConversions = true;
1370 // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
1374 // FIXME: ODR-checking for merging lambdas (this happens, for instance,
1375 // when they occur within the body of a function template specialization).
1378 if (DetectedOdrViolation)
1379 Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
1382 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D) {
1383 struct CXXRecordDecl::DefinitionData *DD;
1384 ASTContext &C = Reader.getContext();
1386 // Determine whether this is a lambda closure type, so that we can
1387 // allocate the appropriate DefinitionData structure.
1388 bool IsLambda = Record[Idx++];
1390 DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
1393 DD = new (C) struct CXXRecordDecl::DefinitionData(D);
1395 ReadCXXDefinitionData(*DD, Record, Idx);
1397 // If we're reading an update record, we might already have a definition for
1398 // this record. If so, just merge into it.
1399 if (D->DefinitionData.getNotUpdated()) {
1400 MergeDefinitionData(D, *DD);
1404 // Propagate the DefinitionData pointer to the canonical declaration, so
1405 // that all other deserialized declarations will see it.
1406 CXXRecordDecl *Canon = D->getCanonicalDecl();
1408 D->DefinitionData = DD;
1409 D->IsCompleteDefinition = true;
1410 } else if (auto *CanonDD = Canon->DefinitionData.getNotUpdated()) {
1411 // We have already deserialized a definition of this record. This
1412 // definition is no longer really a definition. Note that the pre-existing
1413 // definition is the *real* definition.
1414 Reader.MergedDeclContexts.insert(
1415 std::make_pair(D, CanonDD->Definition));
1416 D->DefinitionData = Canon->DefinitionData;
1417 D->IsCompleteDefinition = false;
1418 MergeDefinitionData(D, *DD);
1420 Canon->DefinitionData = DD;
1421 D->DefinitionData = Canon->DefinitionData;
1422 D->IsCompleteDefinition = true;
1424 // Note that we have deserialized a definition. Any declarations
1425 // deserialized before this one will be be given the DefinitionData
1426 // pointer at the end.
1427 Reader.PendingDefinitions.insert(D);
1431 ASTDeclReader::RedeclarableResult
1432 ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
1433 RedeclarableResult Redecl = VisitRecordDeclImpl(D);
1435 ASTContext &C = Reader.getContext();
1438 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1440 switch ((CXXRecKind)Record[Idx++]) {
1441 case CXXRecNotTemplate:
1442 // Merged when we merge the folding set entry in the primary template.
1443 if (!isa<ClassTemplateSpecializationDecl>(D))
1444 mergeRedeclarable(D, Redecl);
1446 case CXXRecTemplate: {
1447 // Merged when we merge the template.
1448 ClassTemplateDecl *Template = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1449 D->TemplateOrInstantiation = Template;
1450 if (!Template->getTemplatedDecl()) {
1451 // We've not actually loaded the ClassTemplateDecl yet, because we're
1452 // currently being loaded as its pattern. Rely on it to set up our
1453 // TypeForDecl (see VisitClassTemplateDecl).
1455 // Beware: we do not yet know our canonical declaration, and may still
1456 // get merged once the surrounding class template has got off the ground.
1457 TypeIDForTypeDecl = 0;
1461 case CXXRecMemberSpecialization: {
1462 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1463 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1464 SourceLocation POI = ReadSourceLocation(Record, Idx);
1465 MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1466 MSI->setPointOfInstantiation(POI);
1467 D->TemplateOrInstantiation = MSI;
1468 mergeRedeclarable(D, Redecl);
1473 bool WasDefinition = Record[Idx++];
1475 ReadCXXRecordDefinition(D);
1477 // Propagate DefinitionData pointer from the canonical declaration.
1478 D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1480 // Lazily load the key function to avoid deserializing every method so we can
1482 if (WasDefinition) {
1483 DeclID KeyFn = ReadDeclID(Record, Idx);
1484 if (KeyFn && D->IsCompleteDefinition)
1485 // FIXME: This is wrong for the ARM ABI, where some other module may have
1486 // made this function no longer be a key function. We need an update
1487 // record or similar for that case.
1488 C.KeyFunctions[D] = KeyFn;
1494 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1495 VisitFunctionDecl(D);
1496 unsigned NumOverridenMethods = Record[Idx++];
1497 while (NumOverridenMethods--) {
1498 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1499 // MD may be initializing.
1500 if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1501 Reader.getContext().addOverriddenMethod(D, MD);
1505 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1506 VisitCXXMethodDecl(D);
1508 if (auto *CD = ReadDeclAs<CXXConstructorDecl>(Record, Idx))
1509 D->setInheritedConstructor(CD);
1510 D->IsExplicitSpecified = Record[Idx++];
1511 // FIXME: We should defer loading this until we need the constructor's body.
1512 std::tie(D->CtorInitializers, D->NumCtorInitializers) =
1513 Reader.ReadCXXCtorInitializers(F, Record, Idx);
1516 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1517 VisitCXXMethodDecl(D);
1519 D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1522 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1523 VisitCXXMethodDecl(D);
1524 D->IsExplicitSpecified = Record[Idx++];
1527 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1529 D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1530 D->ImportedAndComplete.setInt(Record[Idx++]);
1531 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1532 for (unsigned I = 0, N = Record.back(); I != N; ++I)
1533 StoredLocs[I] = ReadSourceLocation(Record, Idx);
1534 ++Idx; // The number of stored source locations.
1537 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1539 D->setColonLoc(ReadSourceLocation(Record, Idx));
1542 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1544 if (Record[Idx++]) // hasFriendDecl
1545 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1547 D->Friend = GetTypeSourceInfo(Record, Idx);
1548 for (unsigned i = 0; i != D->NumTPLists; ++i)
1549 D->getTPLists()[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1550 D->NextFriend = ReadDeclID(Record, Idx);
1551 D->UnsupportedFriend = (Record[Idx++] != 0);
1552 D->FriendLoc = ReadSourceLocation(Record, Idx);
1555 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1557 unsigned NumParams = Record[Idx++];
1558 D->NumParams = NumParams;
1559 D->Params = new TemplateParameterList*[NumParams];
1560 for (unsigned i = 0; i != NumParams; ++i)
1561 D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1562 if (Record[Idx++]) // HasFriendDecl
1563 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1565 D->Friend = GetTypeSourceInfo(Record, Idx);
1566 D->FriendLoc = ReadSourceLocation(Record, Idx);
1569 DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1572 DeclID PatternID = ReadDeclID(Record, Idx);
1573 NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
1574 TemplateParameterList* TemplateParams
1575 = Reader.ReadTemplateParameterList(F, Record, Idx);
1576 D->init(TemplatedDecl, TemplateParams);
1578 // FIXME: If this is a redeclaration of a template from another module, handle
1579 // inheritance of default template arguments.
1584 ASTDeclReader::RedeclarableResult
1585 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1586 RedeclarableResult Redecl = VisitRedeclarable(D);
1588 // Make sure we've allocated the Common pointer first. We do this before
1589 // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1590 RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1591 if (!CanonD->Common) {
1592 CanonD->Common = CanonD->newCommon(Reader.getContext());
1593 Reader.PendingDefinitions.insert(CanonD);
1595 D->Common = CanonD->Common;
1597 // If this is the first declaration of the template, fill in the information
1598 // for the 'common' pointer.
1599 if (ThisDeclID == Redecl.getFirstID()) {
1600 if (RedeclarableTemplateDecl *RTD
1601 = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1602 assert(RTD->getKind() == D->getKind() &&
1603 "InstantiatedFromMemberTemplate kind mismatch");
1604 D->setInstantiatedFromMemberTemplate(RTD);
1606 D->setMemberSpecialization();
1610 DeclID PatternID = VisitTemplateDecl(D);
1611 D->IdentifierNamespace = Record[Idx++];
1613 mergeRedeclarable(D, Redecl, PatternID);
1615 // If we merged the template with a prior declaration chain, merge the common
1617 // FIXME: Actually merge here, don't just overwrite.
1618 D->Common = D->getCanonicalDecl()->Common;
1623 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1624 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1626 if (ThisDeclID == Redecl.getFirstID()) {
1627 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1628 // the specializations.
1629 SmallVector<serialization::DeclID, 2> SpecIDs;
1630 SpecIDs.push_back(0);
1633 unsigned Size = Record[Idx++];
1635 for (unsigned I = 0; I != Size; ++I)
1636 SpecIDs.push_back(ReadDeclID(Record, Idx));
1638 // Partial specializations.
1639 Size = Record[Idx++];
1641 for (unsigned I = 0; I != Size; ++I)
1642 SpecIDs.push_back(ReadDeclID(Record, Idx));
1644 ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1646 typedef serialization::DeclID DeclID;
1648 // FIXME: Append specializations!
1649 CommonPtr->LazySpecializations
1650 = new (Reader.getContext()) DeclID [SpecIDs.size()];
1651 memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1652 SpecIDs.size() * sizeof(DeclID));
1656 if (D->getTemplatedDecl()->TemplateOrInstantiation) {
1657 // We were loaded before our templated declaration was. We've not set up
1658 // its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
1660 Reader.Context.getInjectedClassNameType(
1661 D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
1665 /// TODO: Unify with ClassTemplateDecl version?
1666 /// May require unifying ClassTemplateDecl and
1667 /// VarTemplateDecl beyond TemplateDecl...
1668 void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
1669 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1671 if (ThisDeclID == Redecl.getFirstID()) {
1672 // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
1673 // the specializations.
1674 SmallVector<serialization::DeclID, 2> SpecIDs;
1675 SpecIDs.push_back(0);
1678 unsigned Size = Record[Idx++];
1680 for (unsigned I = 0; I != Size; ++I)
1681 SpecIDs.push_back(ReadDeclID(Record, Idx));
1683 // Partial specializations.
1684 Size = Record[Idx++];
1686 for (unsigned I = 0; I != Size; ++I)
1687 SpecIDs.push_back(ReadDeclID(Record, Idx));
1689 VarTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1691 typedef serialization::DeclID DeclID;
1693 // FIXME: Append specializations!
1694 CommonPtr->LazySpecializations =
1695 new (Reader.getContext()) DeclID[SpecIDs.size()];
1696 memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1697 SpecIDs.size() * sizeof(DeclID));
1702 ASTDeclReader::RedeclarableResult
1703 ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
1704 ClassTemplateSpecializationDecl *D) {
1705 RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
1707 ASTContext &C = Reader.getContext();
1708 if (Decl *InstD = ReadDecl(Record, Idx)) {
1709 if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1710 D->SpecializedTemplate = CTD;
1712 SmallVector<TemplateArgument, 8> TemplArgs;
1713 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1714 TemplateArgumentList *ArgList
1715 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1717 ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1718 = new (C) ClassTemplateSpecializationDecl::
1719 SpecializedPartialSpecialization();
1720 PS->PartialSpecialization
1721 = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1722 PS->TemplateArgs = ArgList;
1723 D->SpecializedTemplate = PS;
1727 SmallVector<TemplateArgument, 8> TemplArgs;
1728 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1729 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1731 D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1732 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1734 bool writtenAsCanonicalDecl = Record[Idx++];
1735 if (writtenAsCanonicalDecl) {
1736 ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1737 if (D->isCanonicalDecl()) { // It's kept in the folding set.
1738 // Set this as, or find, the canonical declaration for this specialization
1739 ClassTemplateSpecializationDecl *CanonSpec;
1740 if (ClassTemplatePartialSpecializationDecl *Partial =
1741 dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1742 CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
1743 .GetOrInsertNode(Partial);
1746 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1748 // If there was already a canonical specialization, merge into it.
1749 if (CanonSpec != D) {
1750 mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
1752 // This declaration might be a definition. Merge with any existing
1754 if (auto *DDD = D->DefinitionData.getNotUpdated()) {
1755 if (auto *CanonDD = CanonSpec->DefinitionData.getNotUpdated()) {
1756 MergeDefinitionData(CanonSpec, *DDD);
1757 Reader.PendingDefinitions.erase(D);
1758 Reader.MergedDeclContexts.insert(
1759 std::make_pair(D, CanonDD->Definition));
1760 D->IsCompleteDefinition = false;
1762 CanonSpec->DefinitionData = D->DefinitionData;
1765 D->DefinitionData = CanonSpec->DefinitionData;
1771 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1772 ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1773 = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1774 ExplicitInfo->TypeAsWritten = TyInfo;
1775 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1776 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1777 D->ExplicitInfo = ExplicitInfo;
1783 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1784 ClassTemplatePartialSpecializationDecl *D) {
1785 RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
1787 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1788 D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
1790 // These are read/set from/to the first declaration.
1791 if (ThisDeclID == Redecl.getFirstID()) {
1792 D->InstantiatedFromMember.setPointer(
1793 ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1794 D->InstantiatedFromMember.setInt(Record[Idx++]);
1798 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1799 ClassScopeFunctionSpecializationDecl *D) {
1801 D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1804 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1805 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1807 if (ThisDeclID == Redecl.getFirstID()) {
1808 // This FunctionTemplateDecl owns a CommonPtr; read it.
1810 // Read the function specialization declaration IDs. The specializations
1811 // themselves will be loaded if they're needed.
1812 if (unsigned NumSpecs = Record[Idx++]) {
1813 // FIXME: Append specializations!
1814 FunctionTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1815 CommonPtr->LazySpecializations = new (Reader.getContext())
1816 serialization::DeclID[NumSpecs + 1];
1817 CommonPtr->LazySpecializations[0] = NumSpecs;
1818 for (unsigned I = 0; I != NumSpecs; ++I)
1819 CommonPtr->LazySpecializations[I + 1] = ReadDeclID(Record, Idx);
1824 /// TODO: Unify with ClassTemplateSpecializationDecl version?
1825 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
1826 /// VarTemplate(Partial)SpecializationDecl with a new data
1827 /// structure Template(Partial)SpecializationDecl, and
1828 /// using Template(Partial)SpecializationDecl as input type.
1829 ASTDeclReader::RedeclarableResult
1830 ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
1831 VarTemplateSpecializationDecl *D) {
1832 RedeclarableResult Redecl = VisitVarDeclImpl(D);
1834 ASTContext &C = Reader.getContext();
1835 if (Decl *InstD = ReadDecl(Record, Idx)) {
1836 if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
1837 D->SpecializedTemplate = VTD;
1839 SmallVector<TemplateArgument, 8> TemplArgs;
1840 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1841 TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
1842 C, TemplArgs.data(), TemplArgs.size());
1843 VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
1845 VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
1846 PS->PartialSpecialization =
1847 cast<VarTemplatePartialSpecializationDecl>(InstD);
1848 PS->TemplateArgs = ArgList;
1849 D->SpecializedTemplate = PS;
1854 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1855 VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
1856 new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
1857 ExplicitInfo->TypeAsWritten = TyInfo;
1858 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1859 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1860 D->ExplicitInfo = ExplicitInfo;
1863 SmallVector<TemplateArgument, 8> TemplArgs;
1864 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1866 TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
1867 D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1868 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1870 bool writtenAsCanonicalDecl = Record[Idx++];
1871 if (writtenAsCanonicalDecl) {
1872 VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>(Record, Idx);
1873 if (D->isCanonicalDecl()) { // It's kept in the folding set.
1874 if (VarTemplatePartialSpecializationDecl *Partial =
1875 dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
1876 CanonPattern->getCommonPtr()->PartialSpecializations
1877 .GetOrInsertNode(Partial);
1879 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1887 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
1888 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
1889 /// VarTemplate(Partial)SpecializationDecl with a new data
1890 /// structure Template(Partial)SpecializationDecl, and
1891 /// using Template(Partial)SpecializationDecl as input type.
1892 void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
1893 VarTemplatePartialSpecializationDecl *D) {
1894 RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
1896 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1897 D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
1899 // These are read/set from/to the first declaration.
1900 if (ThisDeclID == Redecl.getFirstID()) {
1901 D->InstantiatedFromMember.setPointer(
1902 ReadDeclAs<VarTemplatePartialSpecializationDecl>(Record, Idx));
1903 D->InstantiatedFromMember.setInt(Record[Idx++]);
1907 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1910 D->setDeclaredWithTypename(Record[Idx++]);
1912 bool Inherited = Record[Idx++];
1913 TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1914 D->setDefaultArgument(DefArg, Inherited);
1917 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1918 VisitDeclaratorDecl(D);
1919 // TemplateParmPosition.
1920 D->setDepth(Record[Idx++]);
1921 D->setPosition(Record[Idx++]);
1922 if (D->isExpandedParameterPack()) {
1923 void **Data = reinterpret_cast<void **>(D + 1);
1924 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1925 Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1926 Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1929 // Rest of NonTypeTemplateParmDecl.
1930 D->ParameterPack = Record[Idx++];
1931 if (Record[Idx++]) {
1932 Expr *DefArg = Reader.ReadExpr(F);
1933 bool Inherited = Record[Idx++];
1934 D->setDefaultArgument(DefArg, Inherited);
1939 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1940 VisitTemplateDecl(D);
1941 // TemplateParmPosition.
1942 D->setDepth(Record[Idx++]);
1943 D->setPosition(Record[Idx++]);
1944 if (D->isExpandedParameterPack()) {
1945 void **Data = reinterpret_cast<void **>(D + 1);
1946 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1948 Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
1950 // Rest of TemplateTemplateParmDecl.
1951 TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1952 bool IsInherited = Record[Idx++];
1953 D->setDefaultArgument(Arg, IsInherited);
1954 D->ParameterPack = Record[Idx++];
1958 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1959 VisitRedeclarableTemplateDecl(D);
1962 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1964 D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
1965 D->AssertExprAndFailed.setInt(Record[Idx++]);
1966 D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
1967 D->RParenLoc = ReadSourceLocation(Record, Idx);
1970 void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
1974 std::pair<uint64_t, uint64_t>
1975 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1976 uint64_t LexicalOffset = Record[Idx++];
1977 uint64_t VisibleOffset = Record[Idx++];
1978 return std::make_pair(LexicalOffset, VisibleOffset);
1981 template <typename T>
1982 ASTDeclReader::RedeclarableResult
1983 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1984 DeclID FirstDeclID = ReadDeclID(Record, Idx);
1986 // 0 indicates that this declaration was the only declaration of its entity,
1987 // and is used for space optimization.
1988 if (FirstDeclID == 0)
1989 FirstDeclID = ThisDeclID;
1991 T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
1992 if (FirstDecl != D) {
1993 // We delay loading of the redeclaration chain to avoid deeply nested calls.
1994 // We temporarily set the first (canonical) declaration as the previous one
1995 // which is the one that matters and mark the real previous DeclID to be
1996 // loaded & attached later on.
1997 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
2000 // Note that this declaration has been deserialized.
2001 Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
2003 // The result structure takes care to note that we need to load the
2004 // other declaration chains for this ID.
2005 return RedeclarableResult(Reader, FirstDeclID,
2006 static_cast<T *>(D)->getKind());
2009 /// \brief Attempts to merge the given declaration (D) with another declaration
2010 /// of the same entity.
2011 template<typename T>
2012 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
2013 RedeclarableResult &Redecl,
2014 DeclID TemplatePatternID) {
2015 T *D = static_cast<T*>(DBase);
2016 T *DCanon = D->getCanonicalDecl();
2018 (!Reader.getContext().getLangOpts().Modules ||
2019 Reader.getOwningModuleFile(DCanon) == Reader.getOwningModuleFile(D))) {
2020 // All redeclarations between this declaration and its originally-canonical
2021 // declaration get pulled in when we load DCanon; we don't need to
2022 // perform any more merging now.
2026 // If modules are not available, there is no reason to perform this merge.
2027 if (!Reader.getContext().getLangOpts().Modules)
2030 if (FindExistingResult ExistingRes = findExisting(D))
2031 if (T *Existing = ExistingRes)
2032 mergeRedeclarable(D, Existing, Redecl, TemplatePatternID);
2035 /// \brief "Cast" to type T, asserting if we don't have an implicit conversion.
2036 /// We use this to put code in a template that will only be valid for certain
2038 template<typename T> static T assert_cast(T t) { return t; }
2039 template<typename T> static T assert_cast(...) {
2040 llvm_unreachable("bad assert_cast");
2043 /// \brief Merge together the pattern declarations from two template
2045 void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D,
2046 RedeclarableTemplateDecl *Existing,
2048 auto *DPattern = D->getTemplatedDecl();
2049 auto *ExistingPattern = Existing->getTemplatedDecl();
2050 RedeclarableResult Result(Reader, DPattern->getCanonicalDecl()->getGlobalID(),
2051 DPattern->getKind());
2052 if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {
2053 // Merge with any existing definition.
2054 // FIXME: This is duplicated in several places. Refactor.
2055 auto *ExistingClass =
2056 cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();
2057 if (auto *DDD = DClass->DefinitionData.getNotUpdated()) {
2058 if (auto *ExistingDD = ExistingClass->DefinitionData.getNotUpdated()) {
2059 MergeDefinitionData(ExistingClass, *DDD);
2060 Reader.PendingDefinitions.erase(DClass);
2061 Reader.MergedDeclContexts.insert(
2062 std::make_pair(DClass, ExistingDD->Definition));
2063 DClass->IsCompleteDefinition = false;
2065 ExistingClass->DefinitionData = DClass->DefinitionData;
2068 DClass->DefinitionData = ExistingClass->DefinitionData;
2070 return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
2073 if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
2074 return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
2076 if (auto *DVar = dyn_cast<VarDecl>(DPattern))
2077 return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
2078 llvm_unreachable("merged an unknown kind of redeclarable template");
2081 /// \brief Attempts to merge the given declaration (D) with another declaration
2082 /// of the same entity.
2083 template<typename T>
2084 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase, T *Existing,
2085 RedeclarableResult &Redecl,
2086 DeclID TemplatePatternID) {
2087 T *D = static_cast<T*>(DBase);
2088 T *ExistingCanon = Existing->getCanonicalDecl();
2089 T *DCanon = D->getCanonicalDecl();
2090 if (ExistingCanon != DCanon) {
2091 assert(DCanon->getGlobalID() == Redecl.getFirstID());
2093 // Have our redeclaration link point back at the canonical declaration
2094 // of the existing declaration, so that this declaration has the
2095 // appropriate canonical declaration.
2096 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
2098 // When we merge a namespace, update its pointer to the first namespace.
2099 if (auto *Namespace = dyn_cast<NamespaceDecl>(D))
2100 Namespace->AnonOrFirstNamespaceAndInline.setPointer(
2101 assert_cast<NamespaceDecl*>(ExistingCanon));
2103 // When we merge a template, merge its pattern.
2104 if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
2105 mergeTemplatePattern(
2106 DTemplate, assert_cast<RedeclarableTemplateDecl*>(ExistingCanon),
2109 // If this declaration was the canonical declaration, make a note of
2110 // that. We accept the linear algorithm here because the number of
2111 // unique canonical declarations of an entity should always be tiny.
2113 SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
2114 if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
2116 Merged.push_back(Redecl.getFirstID());
2121 /// \brief Attempts to merge the given declaration (D) with another declaration
2122 /// of the same entity, for the case where the entity is not actually
2123 /// redeclarable. This happens, for instance, when merging the fields of
2124 /// identical class definitions from two different modules.
2125 template<typename T>
2126 void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
2127 // If modules are not available, there is no reason to perform this merge.
2128 if (!Reader.getContext().getLangOpts().Modules)
2131 // ODR-based merging is only performed in C++. In C, identically-named things
2132 // in different translation units are not redeclarations (but may still have
2133 // compatible types).
2134 if (!Reader.getContext().getLangOpts().CPlusPlus)
2137 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
2138 if (T *Existing = ExistingRes)
2139 Reader.Context.setPrimaryMergedDecl(static_cast<T*>(D),
2140 Existing->getCanonicalDecl());
2143 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2145 unsigned NumVars = D->varlist_size();
2146 SmallVector<Expr *, 16> Vars;
2147 Vars.reserve(NumVars);
2148 for (unsigned i = 0; i != NumVars; ++i) {
2149 Vars.push_back(Reader.ReadExpr(F));
2154 //===----------------------------------------------------------------------===//
2155 // Attribute Reading
2156 //===----------------------------------------------------------------------===//
2158 /// \brief Reads attributes from the current stream position.
2159 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
2160 const RecordData &Record, unsigned &Idx) {
2161 for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
2162 Attr *New = nullptr;
2163 attr::Kind Kind = (attr::Kind)Record[Idx++];
2164 SourceRange Range = ReadSourceRange(F, Record, Idx);
2166 #include "clang/Serialization/AttrPCHRead.inc"
2168 assert(New && "Unable to decode attribute?");
2169 Attrs.push_back(New);
2173 //===----------------------------------------------------------------------===//
2174 // ASTReader Implementation
2175 //===----------------------------------------------------------------------===//
2177 /// \brief Note that we have loaded the declaration with the given
2180 /// This routine notes that this declaration has already been loaded,
2181 /// so that future GetDecl calls will return this declaration rather
2182 /// than trying to load a new declaration.
2183 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
2184 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
2185 DeclsLoaded[Index] = D;
2189 /// \brief Determine whether the consumer will be interested in seeing
2190 /// this declaration (via HandleTopLevelDecl).
2192 /// This routine should return true for anything that might affect
2193 /// code generation, e.g., inline function definitions, Objective-C
2194 /// declarations with metadata, etc.
2195 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
2196 // An ObjCMethodDecl is never considered as "interesting" because its
2197 // implementation container always is.
2199 if (isa<FileScopeAsmDecl>(D) ||
2200 isa<ObjCProtocolDecl>(D) ||
2201 isa<ObjCImplDecl>(D) ||
2204 if (VarDecl *Var = dyn_cast<VarDecl>(D))
2205 return Var->isFileVarDecl() &&
2206 Var->isThisDeclarationADefinition() == VarDecl::Definition;
2207 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
2208 return Func->doesThisDeclarationHaveABody() || HasBody;
2213 /// \brief Get the correct cursor and offset for loading a declaration.
2214 ASTReader::RecordLocation
2215 ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
2216 // See if there's an override.
2217 DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
2218 if (It != ReplacedDecls.end()) {
2219 RawLocation = It->second.RawLoc;
2220 return RecordLocation(It->second.Mod, It->second.Offset);
2223 GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
2224 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
2225 ModuleFile *M = I->second;
2227 DOffs = M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
2228 RawLocation = DOffs.Loc;
2229 return RecordLocation(M, DOffs.BitOffset);
2232 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
2233 ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
2234 = GlobalBitOffsetsMap.find(GlobalOffset);
2236 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
2237 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
2240 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
2241 return LocalOffset + M.GlobalBitOffset;
2244 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2245 const TemplateParameterList *Y);
2247 /// \brief Determine whether two template parameters are similar enough
2248 /// that they may be used in declarations of the same template.
2249 static bool isSameTemplateParameter(const NamedDecl *X,
2250 const NamedDecl *Y) {
2251 if (X->getKind() != Y->getKind())
2254 if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
2255 const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
2256 return TX->isParameterPack() == TY->isParameterPack();
2259 if (const NonTypeTemplateParmDecl *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
2260 const NonTypeTemplateParmDecl *TY = cast<NonTypeTemplateParmDecl>(Y);
2261 return TX->isParameterPack() == TY->isParameterPack() &&
2262 TX->getASTContext().hasSameType(TX->getType(), TY->getType());
2265 const TemplateTemplateParmDecl *TX = cast<TemplateTemplateParmDecl>(X);
2266 const TemplateTemplateParmDecl *TY = cast<TemplateTemplateParmDecl>(Y);
2267 return TX->isParameterPack() == TY->isParameterPack() &&
2268 isSameTemplateParameterList(TX->getTemplateParameters(),
2269 TY->getTemplateParameters());
2272 /// \brief Determine whether two template parameter lists are similar enough
2273 /// that they may be used in declarations of the same template.
2274 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2275 const TemplateParameterList *Y) {
2276 if (X->size() != Y->size())
2279 for (unsigned I = 0, N = X->size(); I != N; ++I)
2280 if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
2286 /// \brief Determine whether the two declarations refer to the same entity.
2287 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
2288 assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
2293 // Must be in the same context.
2294 if (!X->getDeclContext()->getRedeclContext()->Equals(
2295 Y->getDeclContext()->getRedeclContext()))
2298 // Two typedefs refer to the same entity if they have the same underlying
2300 if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
2301 if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
2302 return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
2303 TypedefY->getUnderlyingType());
2305 // Must have the same kind.
2306 if (X->getKind() != Y->getKind())
2309 // Objective-C classes and protocols with the same name always match.
2310 if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
2313 if (isa<ClassTemplateSpecializationDecl>(X)) {
2314 // No need to handle these here: we merge them when adding them to the
2319 // Compatible tags match.
2320 if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
2321 TagDecl *TagY = cast<TagDecl>(Y);
2322 return (TagX->getTagKind() == TagY->getTagKind()) ||
2323 ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
2324 TagX->getTagKind() == TTK_Interface) &&
2325 (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
2326 TagY->getTagKind() == TTK_Interface));
2329 // Functions with the same type and linkage match.
2330 // FIXME: This needs to cope with function template specializations,
2331 // merging of prototyped/non-prototyped functions, etc.
2332 if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
2333 FunctionDecl *FuncY = cast<FunctionDecl>(Y);
2334 return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
2335 FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
2338 // Variables with the same type and linkage match.
2339 if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
2340 VarDecl *VarY = cast<VarDecl>(Y);
2341 return (VarX->getLinkageInternal() == VarY->getLinkageInternal()) &&
2342 VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
2345 // Namespaces with the same name and inlinedness match.
2346 if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
2347 NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
2348 return NamespaceX->isInline() == NamespaceY->isInline();
2351 // Identical template names and kinds match if their template parameter lists
2352 // and patterns match.
2353 if (TemplateDecl *TemplateX = dyn_cast<TemplateDecl>(X)) {
2354 TemplateDecl *TemplateY = cast<TemplateDecl>(Y);
2355 return isSameEntity(TemplateX->getTemplatedDecl(),
2356 TemplateY->getTemplatedDecl()) &&
2357 isSameTemplateParameterList(TemplateX->getTemplateParameters(),
2358 TemplateY->getTemplateParameters());
2361 // Fields with the same name and the same type match.
2362 if (FieldDecl *FDX = dyn_cast<FieldDecl>(X)) {
2363 FieldDecl *FDY = cast<FieldDecl>(Y);
2364 // FIXME: Diagnose if the types don't match.
2365 // FIXME: Also check the bitwidth is odr-equivalent, if any.
2366 return X->getASTContext().hasSameType(FDX->getType(), FDY->getType());
2369 // Enumerators with the same name match.
2370 if (isa<EnumConstantDecl>(X))
2371 // FIXME: Also check the value is odr-equivalent.
2374 // Using shadow declarations with the same target match.
2375 if (UsingShadowDecl *USX = dyn_cast<UsingShadowDecl>(X)) {
2376 UsingShadowDecl *USY = cast<UsingShadowDecl>(Y);
2377 return USX->getTargetDecl() == USY->getTargetDecl();
2380 // FIXME: Many other cases to implement.
2384 /// Find the context in which we should search for previous declarations when
2385 /// looking for declarations to merge.
2386 static DeclContext *getPrimaryContextForMerging(DeclContext *DC) {
2387 if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
2388 return ND->getOriginalNamespace();
2390 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC))
2391 return RD->getDefinition();
2393 if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
2394 return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition()
2400 ASTDeclReader::FindExistingResult::~FindExistingResult() {
2401 if (!AddResult || Existing)
2404 DeclContext *DC = New->getDeclContext()->getRedeclContext();
2405 if (DC->isTranslationUnit() && Reader.SemaObj) {
2406 Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName());
2407 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
2408 // Add the declaration to its redeclaration context so later merging
2409 // lookups will find it.
2410 MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
2414 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
2415 DeclarationName Name = D->getDeclName();
2417 // Don't bother trying to find unnamed declarations.
2418 FindExistingResult Result(Reader, D, /*Existing=*/nullptr);
2419 // FIXME: We may still need to pull in the redeclaration chain; there can
2420 // be redeclarations via 'decltype'.
2425 // FIXME: Bail out for non-canonical declarations. We will have performed any
2426 // necessary merging already.
2428 DeclContext *DC = D->getDeclContext()->getRedeclContext();
2429 if (DC->isTranslationUnit() && Reader.SemaObj) {
2430 IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
2432 // Temporarily consider the identifier to be up-to-date. We don't want to
2433 // cause additional lookups here.
2434 class UpToDateIdentifierRAII {
2439 explicit UpToDateIdentifierRAII(IdentifierInfo *II)
2440 : II(II), WasOutToDate(false)
2443 WasOutToDate = II->isOutOfDate();
2445 II->setOutOfDate(false);
2449 ~UpToDateIdentifierRAII() {
2451 II->setOutOfDate(true);
2453 } UpToDate(Name.getAsIdentifierInfo());
2455 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2456 IEnd = IdResolver.end();
2458 if (isSameEntity(*I, D))
2459 return FindExistingResult(Reader, D, *I);
2461 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
2462 DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
2463 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
2464 if (isSameEntity(*I, D))
2465 return FindExistingResult(Reader, D, *I);
2468 // Not in a mergeable context.
2469 return FindExistingResult(Reader);
2472 // If this declaration is from a merged context, make a note that we need to
2473 // check that the canonical definition of that context contains the decl.
2475 // FIXME: We should do something similar if we merge two definitions of the
2476 // same template specialization into the same CXXRecordDecl.
2477 if (Reader.MergedDeclContexts.count(D->getLexicalDeclContext()))
2478 Reader.PendingOdrMergeChecks.push_back(D);
2480 return FindExistingResult(Reader, D, /*Existing=*/nullptr);
2483 template<typename DeclT>
2484 void ASTDeclReader::attachPreviousDeclImpl(Redeclarable<DeclT> *D,
2486 D->RedeclLink.setPrevious(cast<DeclT>(Previous));
2488 void ASTDeclReader::attachPreviousDeclImpl(...) {
2489 llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
2492 void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *Previous) {
2493 assert(D && Previous);
2495 switch (D->getKind()) {
2496 #define ABSTRACT_DECL(TYPE)
2497 #define DECL(TYPE, BASE) \
2499 attachPreviousDeclImpl(cast<TYPE##Decl>(D), Previous); \
2501 #include "clang/AST/DeclNodes.inc"
2504 // If the declaration was visible in one module, a redeclaration of it in
2505 // another module remains visible even if it wouldn't be visible by itself.
2507 // FIXME: In this case, the declaration should only be visible if a module
2508 // that makes it visible has been imported.
2509 D->IdentifierNamespace |=
2510 Previous->IdentifierNamespace &
2511 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
2513 // If the previous declaration is marked as used, then this declaration should
2518 // If the previous declaration is an inline function declaration, then this
2519 // declaration is too.
2520 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
2521 if (cast<FunctionDecl>(Previous)->IsInline != FD->IsInline) {
2522 // FIXME: [dcl.fct.spec]p4:
2523 // If a function with external linkage is declared inline in one
2524 // translation unit, it shall be declared inline in all translation
2525 // units in which it appears.
2527 // Be careful of this case:
2530 // template<typename T> struct X { void f(); };
2531 // template<typename T> inline void X<T>::f() {}
2533 // module B instantiates the declaration of X<int>::f
2534 // module C instantiates the definition of X<int>::f
2536 // If module B and C are merged, we do not have a violation of this rule.
2538 //if (!FD->IsInline || Previous->getOwningModule())
2539 // Diag(FD->getLocation(), diag::err_odr_differing_inline);
2540 FD->IsInline = true;
2545 template<typename DeclT>
2546 void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
2547 D->RedeclLink.setLatest(cast<DeclT>(Latest));
2549 void ASTDeclReader::attachLatestDeclImpl(...) {
2550 llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
2553 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
2554 assert(D && Latest);
2556 switch (D->getKind()) {
2557 #define ABSTRACT_DECL(TYPE)
2558 #define DECL(TYPE, BASE) \
2560 attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
2562 #include "clang/AST/DeclNodes.inc"
2566 template<typename DeclT>
2567 void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
2568 D->RedeclLink.markIncomplete();
2570 void ASTDeclReader::markIncompleteDeclChainImpl(...) {
2571 llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
2574 void ASTReader::markIncompleteDeclChain(Decl *D) {
2575 switch (D->getKind()) {
2576 #define ABSTRACT_DECL(TYPE)
2577 #define DECL(TYPE, BASE) \
2579 ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
2581 #include "clang/AST/DeclNodes.inc"
2585 ASTReader::MergedDeclsMap::iterator
2586 ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
2587 // If we don't have any stored merged declarations, just look in the
2588 // merged declarations set.
2589 StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
2590 if (StoredPos == StoredMergedDecls.end())
2591 return MergedDecls.find(Canon);
2593 // Append the stored merged declarations to the merged declarations set.
2594 MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
2595 if (Pos == MergedDecls.end())
2596 Pos = MergedDecls.insert(std::make_pair(Canon,
2597 SmallVector<DeclID, 2>())).first;
2598 Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
2599 StoredMergedDecls.erase(StoredPos);
2601 // Sort and uniquify the set of merged declarations.
2602 llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
2603 Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
2608 /// \brief Read the declaration at the given offset from the AST file.
2609 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
2610 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
2611 unsigned RawLocation = 0;
2612 RecordLocation Loc = DeclCursorForID(ID, RawLocation);
2613 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
2614 // Keep track of where we are in the stream, then jump back there
2615 // after reading this declaration.
2616 SavedStreamPosition SavedPosition(DeclsCursor);
2618 ReadingKindTracker ReadingKind(Read_Decl, *this);
2620 // Note that we are loading a declaration record.
2621 Deserializing ADecl(this);
2623 DeclsCursor.JumpToBit(Loc.Offset);
2625 unsigned Code = DeclsCursor.ReadCode();
2627 ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
2630 switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
2631 case DECL_CONTEXT_LEXICAL:
2632 case DECL_CONTEXT_VISIBLE:
2633 llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
2635 D = TypedefDecl::CreateDeserialized(Context, ID);
2637 case DECL_TYPEALIAS:
2638 D = TypeAliasDecl::CreateDeserialized(Context, ID);
2641 D = EnumDecl::CreateDeserialized(Context, ID);
2644 D = RecordDecl::CreateDeserialized(Context, ID);
2646 case DECL_ENUM_CONSTANT:
2647 D = EnumConstantDecl::CreateDeserialized(Context, ID);
2650 D = FunctionDecl::CreateDeserialized(Context, ID);
2652 case DECL_LINKAGE_SPEC:
2653 D = LinkageSpecDecl::CreateDeserialized(Context, ID);
2656 D = LabelDecl::CreateDeserialized(Context, ID);
2658 case DECL_NAMESPACE:
2659 D = NamespaceDecl::CreateDeserialized(Context, ID);
2661 case DECL_NAMESPACE_ALIAS:
2662 D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
2665 D = UsingDecl::CreateDeserialized(Context, ID);
2667 case DECL_USING_SHADOW:
2668 D = UsingShadowDecl::CreateDeserialized(Context, ID);
2670 case DECL_USING_DIRECTIVE:
2671 D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
2673 case DECL_UNRESOLVED_USING_VALUE:
2674 D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
2676 case DECL_UNRESOLVED_USING_TYPENAME:
2677 D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
2679 case DECL_CXX_RECORD:
2680 D = CXXRecordDecl::CreateDeserialized(Context, ID);
2682 case DECL_CXX_METHOD:
2683 D = CXXMethodDecl::CreateDeserialized(Context, ID);
2685 case DECL_CXX_CONSTRUCTOR:
2686 D = CXXConstructorDecl::CreateDeserialized(Context, ID);
2688 case DECL_CXX_DESTRUCTOR:
2689 D = CXXDestructorDecl::CreateDeserialized(Context, ID);
2691 case DECL_CXX_CONVERSION:
2692 D = CXXConversionDecl::CreateDeserialized(Context, ID);
2694 case DECL_ACCESS_SPEC:
2695 D = AccessSpecDecl::CreateDeserialized(Context, ID);
2698 D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2700 case DECL_FRIEND_TEMPLATE:
2701 D = FriendTemplateDecl::CreateDeserialized(Context, ID);
2703 case DECL_CLASS_TEMPLATE:
2704 D = ClassTemplateDecl::CreateDeserialized(Context, ID);
2706 case DECL_CLASS_TEMPLATE_SPECIALIZATION:
2707 D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2709 case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
2710 D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2712 case DECL_VAR_TEMPLATE:
2713 D = VarTemplateDecl::CreateDeserialized(Context, ID);
2715 case DECL_VAR_TEMPLATE_SPECIALIZATION:
2716 D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2718 case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
2719 D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2721 case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
2722 D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
2724 case DECL_FUNCTION_TEMPLATE:
2725 D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
2727 case DECL_TEMPLATE_TYPE_PARM:
2728 D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
2730 case DECL_NON_TYPE_TEMPLATE_PARM:
2731 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
2733 case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
2734 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2736 case DECL_TEMPLATE_TEMPLATE_PARM:
2737 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
2739 case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
2740 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
2743 case DECL_TYPE_ALIAS_TEMPLATE:
2744 D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
2746 case DECL_STATIC_ASSERT:
2747 D = StaticAssertDecl::CreateDeserialized(Context, ID);
2749 case DECL_OBJC_METHOD:
2750 D = ObjCMethodDecl::CreateDeserialized(Context, ID);
2752 case DECL_OBJC_INTERFACE:
2753 D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
2755 case DECL_OBJC_IVAR:
2756 D = ObjCIvarDecl::CreateDeserialized(Context, ID);
2758 case DECL_OBJC_PROTOCOL:
2759 D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
2761 case DECL_OBJC_AT_DEFS_FIELD:
2762 D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
2764 case DECL_OBJC_CATEGORY:
2765 D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
2767 case DECL_OBJC_CATEGORY_IMPL:
2768 D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
2770 case DECL_OBJC_IMPLEMENTATION:
2771 D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
2773 case DECL_OBJC_COMPATIBLE_ALIAS:
2774 D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
2776 case DECL_OBJC_PROPERTY:
2777 D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
2779 case DECL_OBJC_PROPERTY_IMPL:
2780 D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
2783 D = FieldDecl::CreateDeserialized(Context, ID);
2785 case DECL_INDIRECTFIELD:
2786 D = IndirectFieldDecl::CreateDeserialized(Context, ID);
2789 D = VarDecl::CreateDeserialized(Context, ID);
2791 case DECL_IMPLICIT_PARAM:
2792 D = ImplicitParamDecl::CreateDeserialized(Context, ID);
2795 D = ParmVarDecl::CreateDeserialized(Context, ID);
2797 case DECL_FILE_SCOPE_ASM:
2798 D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
2801 D = BlockDecl::CreateDeserialized(Context, ID);
2803 case DECL_MS_PROPERTY:
2804 D = MSPropertyDecl::CreateDeserialized(Context, ID);
2807 D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2809 case DECL_CXX_BASE_SPECIFIERS:
2810 Error("attempt to read a C++ base-specifier record as a declaration");
2813 // Note: last entry of the ImportDecl record is the number of stored source
2815 D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
2817 case DECL_OMP_THREADPRIVATE:
2818 D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2821 D = EmptyDecl::CreateDeserialized(Context, ID);
2825 assert(D && "Unknown declaration reading AST file");
2826 LoadedDecl(Index, D);
2827 // Set the DeclContext before doing any deserialization, to make sure internal
2828 // calls to Decl::getASTContext() by Decl's methods will find the
2829 // TranslationUnitDecl without crashing.
2830 D->setDeclContext(Context.getTranslationUnitDecl());
2833 // If this declaration is also a declaration context, get the
2834 // offsets for its tables of lexical and visible declarations.
2835 if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
2836 // FIXME: This should really be
2837 // DeclContext *LookupDC = DC->getPrimaryContext();
2838 // but that can walk the redeclaration chain, which might not work yet.
2839 DeclContext *LookupDC = DC;
2840 if (isa<NamespaceDecl>(DC))
2841 LookupDC = DC->getPrimaryContext();
2842 std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
2843 if (Offsets.first || Offsets.second) {
2844 if (Offsets.first != 0)
2845 DC->setHasExternalLexicalStorage(true);
2846 if (Offsets.second != 0)
2847 LookupDC->setHasExternalVisibleStorage(true);
2848 if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
2849 Loc.F->DeclContextInfos[DC]))
2853 // Now add the pending visible updates for this decl context, if it has any.
2854 DeclContextVisibleUpdatesPending::iterator I =
2855 PendingVisibleUpdates.find(ID);
2856 if (I != PendingVisibleUpdates.end()) {
2857 // There are updates. This means the context has external visible
2858 // storage, even if the original stored version didn't.
2859 LookupDC->setHasExternalVisibleStorage(true);
2860 for (const auto &Update : I->second) {
2861 DeclContextInfo &Info = Update.second->DeclContextInfos[DC];
2862 delete Info.NameLookupTableData;
2863 Info.NameLookupTableData = Update.first;
2865 PendingVisibleUpdates.erase(I);
2868 assert(Idx == Record.size());
2870 // Load any relevant update records.
2871 PendingUpdateRecords.push_back(std::make_pair(ID, D));
2873 // Load the categories after recursive loading is finished.
2874 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
2875 if (Class->isThisDeclarationADefinition())
2876 loadObjCCategories(ID, Class);
2878 // If we have deserialized a declaration that has a definition the
2879 // AST consumer might need to know about, queue it.
2880 // We don't pass it to the consumer immediately because we may be in recursive
2881 // loading, and some declarations may still be initializing.
2882 if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
2883 InterestingDecls.push_back(D);
2888 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
2889 // The declaration may have been modified by files later in the chain.
2890 // If this is the case, read the record containing the updates from each file
2891 // and pass it to ASTDeclReader to make the modifications.
2892 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
2893 if (UpdI != DeclUpdateOffsets.end()) {
2894 FileOffsetsTy &UpdateOffsets = UpdI->second;
2895 bool WasInteresting = isConsumerInterestedIn(D, false);
2896 for (FileOffsetsTy::iterator
2897 I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
2898 ModuleFile *F = I->first;
2899 uint64_t Offset = I->second;
2900 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
2901 SavedStreamPosition SavedPosition(Cursor);
2902 Cursor.JumpToBit(Offset);
2904 unsigned Code = Cursor.ReadCode();
2905 unsigned RecCode = Cursor.readRecord(Code, Record);
2907 assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
2910 ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
2911 Reader.UpdateDecl(D, *F, Record);
2913 // We might have made this declaration interesting. If so, remember that
2914 // we need to hand it off to the consumer.
2915 if (!WasInteresting &&
2916 isConsumerInterestedIn(D, Reader.hasPendingBody())) {
2917 InterestingDecls.push_back(D);
2918 WasInteresting = true;
2925 /// \brief Module visitor class that finds all of the redeclarations of a
2927 class RedeclChainVisitor {
2929 SmallVectorImpl<DeclID> &SearchDecls;
2930 llvm::SmallPtrSet<Decl *, 16> &Deserialized;
2931 GlobalDeclID CanonID;
2932 SmallVector<Decl *, 4> Chain;
2935 RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
2936 llvm::SmallPtrSet<Decl *, 16> &Deserialized,
2937 GlobalDeclID CanonID)
2938 : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
2940 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2941 addToChain(Reader.GetDecl(SearchDecls[I]));
2944 static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
2948 return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
2951 void addToChain(Decl *D) {
2955 if (Deserialized.erase(D))
2959 void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
2960 // Map global ID of the first declaration down to the local ID
2961 // used in this module file.
2962 DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
2966 // Perform a binary search to find the local redeclarations for this
2967 // declaration (if any).
2968 const LocalRedeclarationsInfo Compare = { ID, 0 };
2969 const LocalRedeclarationsInfo *Result
2970 = std::lower_bound(M.RedeclarationsMap,
2971 M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
2973 if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
2974 Result->FirstID != ID) {
2975 // If we have a previously-canonical singleton declaration that was
2976 // merged into another redeclaration chain, create a trivial chain
2977 // for this single declaration so that it will get wired into the
2978 // complete redeclaration chain.
2979 if (GlobalID != CanonID &&
2980 GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
2981 GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
2982 addToChain(Reader.GetDecl(GlobalID));
2988 // Dig out all of the redeclarations.
2989 unsigned Offset = Result->Offset;
2990 unsigned N = M.RedeclarationChains[Offset];
2991 M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
2992 for (unsigned I = 0; I != N; ++I)
2993 addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
2996 bool visit(ModuleFile &M) {
2997 // Visit each of the declarations.
2998 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2999 searchForID(M, SearchDecls[I]);
3000 // FIXME: If none of the SearchDecls had local IDs in this module, can
3001 // we avoid searching any ancestor module files?
3005 ArrayRef<Decl *> getChain() const {
3011 void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
3012 Decl *D = GetDecl(ID);
3013 Decl *CanonDecl = D->getCanonicalDecl();
3015 // Determine the set of declaration IDs we'll be searching for.
3016 SmallVector<DeclID, 1> SearchDecls;
3017 GlobalDeclID CanonID = 0;
3018 if (D == CanonDecl) {
3019 SearchDecls.push_back(ID); // Always first.
3022 MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
3023 if (MergedPos != MergedDecls.end())
3024 SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
3026 // Build up the list of redeclarations.
3027 RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
3028 ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
3030 // Retrieve the chains.
3031 ArrayRef<Decl *> Chain = Visitor.getChain();
3035 // Hook up the chains.
3036 Decl *MostRecent = CanonDecl->getMostRecentDecl();
3037 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3038 if (Chain[I] == CanonDecl)
3041 ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent);
3042 MostRecent = Chain[I];
3045 ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
3049 /// \brief Given an ObjC interface, goes through the modules and links to the
3050 /// interface all the categories for it.
3051 class ObjCCategoriesVisitor {
3053 serialization::GlobalDeclID InterfaceID;
3054 ObjCInterfaceDecl *Interface;
3055 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized;
3056 unsigned PreviousGeneration;
3057 ObjCCategoryDecl *Tail;
3058 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
3060 void add(ObjCCategoryDecl *Cat) {
3061 // Only process each category once.
3062 if (!Deserialized.erase(Cat))
3065 // Check for duplicate categories.
3066 if (Cat->getDeclName()) {
3067 ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
3069 Reader.getOwningModuleFile(Existing)
3070 != Reader.getOwningModuleFile(Cat)) {
3071 // FIXME: We should not warn for duplicates in diamond:
3079 // If there are duplicates in ML/MR, there will be warning when
3080 // creating MB *and* when importing MB. We should not warn when
3082 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
3083 << Interface->getDeclName() << Cat->getDeclName();
3084 Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
3085 } else if (!Existing) {
3086 // Record this category.
3091 // Add this category to the end of the chain.
3093 ASTDeclReader::setNextObjCCategory(Tail, Cat);
3095 Interface->setCategoryListRaw(Cat);
3100 ObjCCategoriesVisitor(ASTReader &Reader,
3101 serialization::GlobalDeclID InterfaceID,
3102 ObjCInterfaceDecl *Interface,
3103 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized,
3104 unsigned PreviousGeneration)
3105 : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
3106 Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
3109 // Populate the name -> category map with the set of known categories.
3110 for (auto *Cat : Interface->known_categories()) {
3111 if (Cat->getDeclName())
3112 NameCategoryMap[Cat->getDeclName()] = Cat;
3114 // Keep track of the tail of the category list.
3119 static bool visit(ModuleFile &M, void *UserData) {
3120 return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
3123 bool visit(ModuleFile &M) {
3124 // If we've loaded all of the category information we care about from
3125 // this module file, we're done.
3126 if (M.Generation <= PreviousGeneration)
3129 // Map global ID of the definition down to the local ID used in this
3130 // module file. If there is no such mapping, we'll find nothing here
3131 // (or in any module it imports).
3132 DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
3136 // Perform a binary search to find the local redeclarations for this
3137 // declaration (if any).
3138 const ObjCCategoriesInfo Compare = { LocalID, 0 };
3139 const ObjCCategoriesInfo *Result
3140 = std::lower_bound(M.ObjCCategoriesMap,
3141 M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
3143 if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
3144 Result->DefinitionID != LocalID) {
3145 // We didn't find anything. If the class definition is in this module
3146 // file, then the module files it depends on cannot have any categories,
3147 // so suppress further lookup.
3148 return Reader.isDeclIDFromModule(InterfaceID, M);
3151 // We found something. Dig out all of the categories.
3152 unsigned Offset = Result->Offset;
3153 unsigned N = M.ObjCCategories[Offset];
3154 M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
3155 for (unsigned I = 0; I != N; ++I)
3156 add(cast_or_null<ObjCCategoryDecl>(
3157 Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
3163 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
3164 ObjCInterfaceDecl *D,
3165 unsigned PreviousGeneration) {
3166 ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
3167 PreviousGeneration);
3168 ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
3171 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
3172 const RecordData &Record) {
3173 while (Idx < Record.size()) {
3174 switch ((DeclUpdateKind)Record[Idx++]) {
3175 case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
3176 Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
3177 assert(MD && "couldn't read decl from update record");
3178 cast<CXXRecordDecl>(D)->addedMember(MD);
3182 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
3183 // It will be added to the template's specializations set when loaded.
3184 (void)Reader.ReadDecl(ModuleFile, Record, Idx);
3187 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
3189 = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
3191 // Each module has its own anonymous namespace, which is disjoint from
3192 // any other module's anonymous namespaces, so don't attach the anonymous
3193 // namespace at all.
3194 if (ModuleFile.Kind != MK_Module) {
3195 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
3196 TU->setAnonymousNamespace(Anon);
3198 cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
3203 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
3204 cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
3205 Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3208 case UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION: {
3209 FunctionDecl *FD = cast<FunctionDecl>(D);
3210 if (Reader.PendingBodies[FD]) {
3211 // FIXME: Maybe check for ODR violations.
3212 // It's safe to stop now because this update record is always last.
3216 if (Record[Idx++]) {
3217 // Maintain AST consistency: any later redeclarations of this function
3218 // are inline if this one is. (We might have merged another declaration
3220 for (auto *D = FD->getMostRecentDecl(); /**/;
3221 D = D->getPreviousDecl()) {
3222 D->setImplicitlyInline();
3227 FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3228 if (auto *CD = dyn_cast<CXXConstructorDecl>(FD))
3229 std::tie(CD->CtorInitializers, CD->NumCtorInitializers) =
3230 Reader.ReadCXXCtorInitializers(ModuleFile, Record, Idx);
3231 // Store the offset of the body so we can lazily load it later.
3232 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
3233 HasPendingBody = true;
3234 assert(Idx == Record.size() && "lazy body must be last");
3238 case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
3239 auto *RD = cast<CXXRecordDecl>(D);
3240 bool HadDefinition = RD->getDefinition();
3241 ReadCXXRecordDefinition(RD);
3242 // Visible update is handled separately.
3243 uint64_t LexicalOffset = Record[Idx++];
3244 if (!HadDefinition && LexicalOffset) {
3245 RD->setHasExternalLexicalStorage(true);
3246 Reader.ReadDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
3247 std::make_pair(LexicalOffset, 0),
3248 ModuleFile.DeclContextInfos[RD]);
3251 auto TSK = (TemplateSpecializationKind)Record[Idx++];
3252 SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
3253 if (MemberSpecializationInfo *MSInfo =
3254 RD->getMemberSpecializationInfo()) {
3255 MSInfo->setTemplateSpecializationKind(TSK);
3256 MSInfo->setPointOfInstantiation(POI);
3258 ClassTemplateSpecializationDecl *Spec =
3259 cast<ClassTemplateSpecializationDecl>(RD);
3260 Spec->setTemplateSpecializationKind(TSK);
3261 Spec->setPointOfInstantiation(POI);
3263 if (Record[Idx++]) {
3265 ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx);
3266 SmallVector<TemplateArgument, 8> TemplArgs;
3267 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
3268 auto *TemplArgList = TemplateArgumentList::CreateCopy(
3269 Reader.getContext(), TemplArgs.data(), TemplArgs.size());
3270 Spec->setInstantiationOf(PartialSpec, TemplArgList);
3274 RD->setTagKind((TagTypeKind)Record[Idx++]);
3275 RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3276 RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3277 RD->setRBraceLoc(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3279 if (Record[Idx++]) {
3281 Reader.ReadAttributes(F, Attrs, Record, Idx);
3282 D->setAttrsImpl(Attrs, Reader.getContext());
3287 case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
3288 auto *FD = cast<FunctionDecl>(D);
3289 auto *FPT = FD->getType()->castAs<FunctionProtoType>();
3290 auto EPI = FPT->getExtProtoInfo();
3291 SmallVector<QualType, 8> ExceptionStorage;
3292 Reader.readExceptionSpec(ModuleFile, ExceptionStorage, EPI, Record, Idx);
3293 FD->setType(Reader.Context.getFunctionType(FPT->getReturnType(),
3294 FPT->getParamTypes(), EPI));
3298 case UPD_CXX_DEDUCED_RETURN_TYPE: {
3299 FunctionDecl *FD = cast<FunctionDecl>(D);
3300 Reader.Context.adjustDeducedFunctionResultType(
3301 FD, Reader.readType(ModuleFile, Record, Idx));
3305 case UPD_DECL_MARKED_USED: {
3306 // FIXME: This doesn't send the right notifications if there are
3307 // ASTMutationListeners other than an ASTWriter.
3309 // FIXME: We can't both pull in declarations (and thus create new pending
3310 // redeclaration chains) *and* walk redeclaration chains in this function.
3311 // We should defer the updates that require walking redecl chains.
3313 // Maintain AST consistency: any later redeclarations are used too.
3314 for (auto *Redecl = D->getMostRecentDecl(); /**/;
3315 Redecl = Redecl->getPreviousDecl()) {
3316 Redecl->Used = true;
3323 case UPD_MANGLING_NUMBER:
3324 Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
3327 case UPD_STATIC_LOCAL_NUMBER:
3328 Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);