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/SemaDiagnostic.h"
27 #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> {
41 const DeclID ThisDeclID;
42 const SourceLocation ThisDeclLoc;
43 typedef ASTReader::RecordData RecordData;
44 const RecordData &Record;
46 TypeID TypeIDForTypeDecl;
47 unsigned AnonymousDeclNumber;
48 GlobalDeclID NamedDeclForTagDecl;
49 IdentifierInfo *TypedefNameForLinkage;
53 ///\brief A flag to carry the information for a decl from the entity is
54 /// used. We use it to delay the marking of the canonical decl as used until
55 /// the entire declaration is deserialized and merged.
56 bool IsDeclMarkedUsed;
58 uint64_t GetCurrentCursorOffset();
60 uint64_t ReadLocalOffset(const RecordData &R, unsigned &I) {
61 uint64_t LocalOffset = R[I++];
62 assert(LocalOffset < Offset && "offset point after current record");
63 return LocalOffset ? Offset - LocalOffset : 0;
66 uint64_t ReadGlobalOffset(ModuleFile &F, const RecordData &R, unsigned &I) {
67 uint64_t Local = ReadLocalOffset(R, I);
68 return Local ? Reader.getGlobalBitOffset(F, Local) : 0;
71 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
72 return Reader.ReadSourceLocation(F, R, I);
75 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
76 return Reader.ReadSourceRange(F, R, I);
79 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
80 return Reader.GetTypeSourceInfo(F, R, I);
83 serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
84 return Reader.ReadDeclID(F, R, I);
87 std::string ReadString(const RecordData &R, unsigned &I) {
88 return Reader.ReadString(R, I);
91 void ReadDeclIDList(SmallVectorImpl<DeclID> &IDs) {
92 for (unsigned I = 0, Size = Record[Idx++]; I != Size; ++I)
93 IDs.push_back(ReadDeclID(Record, Idx));
96 Decl *ReadDecl(const RecordData &R, unsigned &I) {
97 return Reader.ReadDecl(F, R, I);
101 T *ReadDeclAs(const RecordData &R, unsigned &I) {
102 return Reader.ReadDeclAs<T>(F, R, I);
105 void ReadQualifierInfo(QualifierInfo &Info,
106 const RecordData &R, unsigned &I) {
107 Reader.ReadQualifierInfo(F, Info, R, I);
110 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
111 const RecordData &R, unsigned &I) {
112 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
115 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
116 const RecordData &R, unsigned &I) {
117 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
120 serialization::SubmoduleID readSubmoduleID(const RecordData &R,
125 return Reader.getGlobalSubmoduleID(F, R[I++]);
128 Module *readModule(const RecordData &R, unsigned &I) {
129 return Reader.getSubmodule(readSubmoduleID(R, I));
132 void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update);
133 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
134 const RecordData &R, unsigned &I);
135 void MergeDefinitionData(CXXRecordDecl *D,
136 struct CXXRecordDecl::DefinitionData &&NewDD);
138 static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
141 static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
142 unsigned Index, NamedDecl *D);
144 /// Results from loading a RedeclarableDecl.
145 class RedeclarableResult {
146 GlobalDeclID FirstID;
151 RedeclarableResult(GlobalDeclID FirstID, Decl *MergeWith, bool IsKeyDecl)
152 : FirstID(FirstID), MergeWith(MergeWith), IsKeyDecl(IsKeyDecl) {}
154 /// \brief Retrieve the first ID.
155 GlobalDeclID getFirstID() const { return FirstID; }
157 /// \brief Is this declaration a key declaration?
158 bool isKeyDecl() const { return IsKeyDecl; }
160 /// \brief Get a known declaration that this should be merged with, if
162 Decl *getKnownMergeTarget() const { return MergeWith; }
165 /// \brief Class used to capture the result of searching for an existing
166 /// declaration of a specific kind and name, along with the ability
167 /// to update the place where this result was found (the declaration
168 /// chain hanging off an identifier or the DeclContext we searched in)
170 class FindExistingResult {
174 mutable bool AddResult;
176 unsigned AnonymousDeclNumber;
177 IdentifierInfo *TypedefNameForLinkage;
179 void operator=(FindExistingResult&) = delete;
182 FindExistingResult(ASTReader &Reader)
183 : Reader(Reader), New(nullptr), Existing(nullptr), AddResult(false),
184 AnonymousDeclNumber(0), TypedefNameForLinkage(nullptr) {}
186 FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,
187 unsigned AnonymousDeclNumber,
188 IdentifierInfo *TypedefNameForLinkage)
189 : Reader(Reader), New(New), Existing(Existing), AddResult(true),
190 AnonymousDeclNumber(AnonymousDeclNumber),
191 TypedefNameForLinkage(TypedefNameForLinkage) {}
193 FindExistingResult(const FindExistingResult &Other)
194 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
195 AddResult(Other.AddResult),
196 AnonymousDeclNumber(Other.AnonymousDeclNumber),
197 TypedefNameForLinkage(Other.TypedefNameForLinkage) {
198 Other.AddResult = false;
201 ~FindExistingResult();
203 /// \brief Suppress the addition of this result into the known set of
205 void suppress() { AddResult = false; }
207 operator NamedDecl*() const { return Existing; }
210 operator T*() const { return dyn_cast_or_null<T>(Existing); }
213 static DeclContext *getPrimaryContextForMerging(ASTReader &Reader,
215 FindExistingResult findExisting(NamedDecl *D);
218 ASTDeclReader(ASTReader &Reader, ASTReader::RecordLocation Loc,
219 DeclID thisDeclID, SourceLocation ThisDeclLoc,
220 const RecordData &Record, unsigned &Idx)
221 : Reader(Reader), F(*Loc.F), Offset(Loc.Offset), ThisDeclID(thisDeclID),
222 ThisDeclLoc(ThisDeclLoc), Record(Record), Idx(Idx),
223 TypeIDForTypeDecl(0), NamedDeclForTagDecl(0),
224 TypedefNameForLinkage(nullptr), HasPendingBody(false),
225 IsDeclMarkedUsed(false) {}
227 template <typename DeclT>
228 static Decl *getMostRecentDeclImpl(Redeclarable<DeclT> *D);
229 static Decl *getMostRecentDeclImpl(...);
230 static Decl *getMostRecentDecl(Decl *D);
232 template <typename DeclT>
233 static void attachPreviousDeclImpl(ASTReader &Reader,
234 Redeclarable<DeclT> *D, Decl *Previous,
236 static void attachPreviousDeclImpl(ASTReader &Reader, ...);
237 static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,
240 template <typename DeclT>
241 static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
242 static void attachLatestDeclImpl(...);
243 static void attachLatestDecl(Decl *D, Decl *latest);
245 template <typename DeclT>
246 static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
247 static void markIncompleteDeclChainImpl(...);
249 /// \brief Determine whether this declaration has a pending body.
250 bool hasPendingBody() const { return HasPendingBody; }
254 void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
255 const RecordData &Record);
257 static void setNextObjCCategory(ObjCCategoryDecl *Cat,
258 ObjCCategoryDecl *Next) {
259 Cat->NextClassCategory = Next;
262 void VisitDecl(Decl *D);
263 void VisitPragmaCommentDecl(PragmaCommentDecl *D);
264 void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
265 void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
266 void VisitNamedDecl(NamedDecl *ND);
267 void VisitLabelDecl(LabelDecl *LD);
268 void VisitNamespaceDecl(NamespaceDecl *D);
269 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
270 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
271 void VisitTypeDecl(TypeDecl *TD);
272 RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
273 void VisitTypedefDecl(TypedefDecl *TD);
274 void VisitTypeAliasDecl(TypeAliasDecl *TD);
275 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
276 RedeclarableResult VisitTagDecl(TagDecl *TD);
277 void VisitEnumDecl(EnumDecl *ED);
278 RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
279 void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
280 RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
281 void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
282 RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
283 ClassTemplateSpecializationDecl *D);
284 void VisitClassTemplateSpecializationDecl(
285 ClassTemplateSpecializationDecl *D) {
286 VisitClassTemplateSpecializationDeclImpl(D);
288 void VisitClassTemplatePartialSpecializationDecl(
289 ClassTemplatePartialSpecializationDecl *D);
290 void VisitClassScopeFunctionSpecializationDecl(
291 ClassScopeFunctionSpecializationDecl *D);
293 VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
294 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
295 VisitVarTemplateSpecializationDeclImpl(D);
297 void VisitVarTemplatePartialSpecializationDecl(
298 VarTemplatePartialSpecializationDecl *D);
299 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
300 void VisitValueDecl(ValueDecl *VD);
301 void VisitEnumConstantDecl(EnumConstantDecl *ECD);
302 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
303 void VisitDeclaratorDecl(DeclaratorDecl *DD);
304 void VisitFunctionDecl(FunctionDecl *FD);
305 void VisitCXXMethodDecl(CXXMethodDecl *D);
306 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
307 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
308 void VisitCXXConversionDecl(CXXConversionDecl *D);
309 void VisitFieldDecl(FieldDecl *FD);
310 void VisitMSPropertyDecl(MSPropertyDecl *FD);
311 void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
312 RedeclarableResult VisitVarDeclImpl(VarDecl *D);
313 void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
314 void VisitImplicitParamDecl(ImplicitParamDecl *PD);
315 void VisitParmVarDecl(ParmVarDecl *PD);
316 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
317 DeclID VisitTemplateDecl(TemplateDecl *D);
318 RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
319 void VisitClassTemplateDecl(ClassTemplateDecl *D);
320 void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
321 void VisitVarTemplateDecl(VarTemplateDecl *D);
322 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
323 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
324 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
325 void VisitUsingDecl(UsingDecl *D);
326 void VisitUsingShadowDecl(UsingShadowDecl *D);
327 void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
328 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
329 void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
330 void VisitImportDecl(ImportDecl *D);
331 void VisitAccessSpecDecl(AccessSpecDecl *D);
332 void VisitFriendDecl(FriendDecl *D);
333 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
334 void VisitStaticAssertDecl(StaticAssertDecl *D);
335 void VisitBlockDecl(BlockDecl *BD);
336 void VisitCapturedDecl(CapturedDecl *CD);
337 void VisitEmptyDecl(EmptyDecl *D);
339 std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
342 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
345 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
346 DeclID TemplatePatternID = 0);
349 void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
350 RedeclarableResult &Redecl,
351 DeclID TemplatePatternID = 0);
354 void mergeMergeable(Mergeable<T> *D);
356 void mergeTemplatePattern(RedeclarableTemplateDecl *D,
357 RedeclarableTemplateDecl *Existing,
358 DeclID DsID, bool IsKeyDecl);
360 ObjCTypeParamList *ReadObjCTypeParamList();
362 // FIXME: Reorder according to DeclNodes.td?
363 void VisitObjCMethodDecl(ObjCMethodDecl *D);
364 void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
365 void VisitObjCContainerDecl(ObjCContainerDecl *D);
366 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
367 void VisitObjCIvarDecl(ObjCIvarDecl *D);
368 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
369 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
370 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
371 void VisitObjCImplDecl(ObjCImplDecl *D);
372 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
373 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
374 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
375 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
376 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
377 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
378 void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
379 void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
381 /// We've merged the definition \p MergedDef into the existing definition
382 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
384 void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef) {
385 if (Def->isHidden()) {
386 // If MergedDef is visible or becomes visible, make the definition visible.
387 if (!MergedDef->isHidden())
389 else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
390 Reader.getContext().mergeDefinitionIntoModule(
391 Def, MergedDef->getImportedOwningModule(),
392 /*NotifyListeners*/ false);
393 Reader.PendingMergedDefinitionsToDeduplicate.insert(Def);
395 auto SubmoduleID = MergedDef->getOwningModuleID();
396 assert(SubmoduleID && "hidden definition in no module");
397 Reader.HiddenNamesMap[Reader.getSubmodule(SubmoduleID)].push_back(Def);
402 } // end namespace clang
405 /// Iterator over the redeclarations of a declaration that have already
406 /// been merged into the same redeclaration chain.
407 template<typename DeclT>
408 class MergedRedeclIterator {
409 DeclT *Start, *Canonical, *Current;
411 MergedRedeclIterator() : Current(nullptr) {}
412 MergedRedeclIterator(DeclT *Start)
413 : Start(Start), Canonical(nullptr), Current(Start) {}
415 DeclT *operator*() { return Current; }
417 MergedRedeclIterator &operator++() {
418 if (Current->isFirstDecl()) {
420 Current = Current->getMostRecentDecl();
422 Current = Current->getPreviousDecl();
424 // If we started in the merged portion, we'll reach our start position
425 // eventually. Otherwise, we'll never reach it, but the second declaration
426 // we reached was the canonical declaration, so stop when we see that one
428 if (Current == Start || Current == Canonical)
433 friend bool operator!=(const MergedRedeclIterator &A,
434 const MergedRedeclIterator &B) {
435 return A.Current != B.Current;
438 } // end anonymous namespace
440 template<typename DeclT>
441 llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) {
442 return llvm::make_range(MergedRedeclIterator<DeclT>(D),
443 MergedRedeclIterator<DeclT>());
446 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
447 return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
450 void ASTDeclReader::Visit(Decl *D) {
451 DeclVisitor<ASTDeclReader, void>::Visit(D);
453 // At this point we have deserialized and merged the decl and it is safe to
454 // update its canonical decl to signal that the entire entity is used.
455 D->getCanonicalDecl()->Used |= IsDeclMarkedUsed;
456 IsDeclMarkedUsed = false;
458 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
460 DeclaratorDecl::ExtInfo *Info =
461 DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
463 GetTypeSourceInfo(Record, Idx);
466 DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
470 if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
471 // We have a fully initialized TypeDecl. Read its type now.
472 TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
474 // If this is a tag declaration with a typedef name for linkage, it's safe
475 // to load that typedef now.
476 if (NamedDeclForTagDecl)
477 cast<TagDecl>(D)->TypedefNameDeclOrQualifier =
478 cast<TypedefNameDecl>(Reader.GetDecl(NamedDeclForTagDecl));
479 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
480 // if we have a fully initialized TypeDecl, we can safely read its type now.
481 ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
482 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
483 // FunctionDecl's body was written last after all other Stmts/Exprs.
484 // We only read it if FD doesn't already have a body (e.g., from another
486 // FIXME: Can we diagnose ODR violations somehow?
488 if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
489 CD->NumCtorInitializers = Record[Idx++];
490 if (CD->NumCtorInitializers)
491 CD->CtorInitializers = ReadGlobalOffset(F, Record, Idx);
493 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
494 HasPendingBody = true;
499 void ASTDeclReader::VisitDecl(Decl *D) {
500 if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
501 isa<ParmVarDecl>(D)) {
502 // We don't want to deserialize the DeclContext of a template
503 // parameter or of a parameter of a function template immediately. These
504 // entities might be used in the formulation of its DeclContext (for
505 // example, a function parameter can be used in decltype() in trailing
506 // return type of the function). Use the translation unit DeclContext as a
508 GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
509 GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
510 if (!LexicalDCIDForTemplateParmDecl)
511 LexicalDCIDForTemplateParmDecl = SemaDCIDForTemplateParmDecl;
512 Reader.addPendingDeclContextInfo(D,
513 SemaDCIDForTemplateParmDecl,
514 LexicalDCIDForTemplateParmDecl);
515 D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
517 DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
518 DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
521 DeclContext *MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
522 // Avoid calling setLexicalDeclContext() directly because it uses
523 // Decl::getASTContext() internally which is unsafe during derialization.
524 D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
525 Reader.getContext());
527 D->setLocation(ThisDeclLoc);
528 D->setInvalidDecl(Record[Idx++]);
529 if (Record[Idx++]) { // hasAttrs
531 Reader.ReadAttributes(F, Attrs, Record, Idx);
532 // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
533 // internally which is unsafe during derialization.
534 D->setAttrsImpl(Attrs, Reader.getContext());
536 D->setImplicit(Record[Idx++]);
537 D->Used = Record[Idx++];
538 IsDeclMarkedUsed |= D->Used;
539 D->setReferenced(Record[Idx++]);
540 D->setTopLevelDeclInObjCContainer(Record[Idx++]);
541 D->setAccess((AccessSpecifier)Record[Idx++]);
542 D->FromASTFile = true;
543 D->setModulePrivate(Record[Idx++]);
544 D->Hidden = D->isModulePrivate();
546 // Determine whether this declaration is part of a (sub)module. If so, it
547 // may not yet be visible.
548 if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
549 // Store the owning submodule ID in the declaration.
550 D->setOwningModuleID(SubmoduleID);
553 // Module-private declarations are never visible, so there is no work to do.
554 } else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
555 // If local visibility is being tracked, this declaration will become
556 // hidden and visible as the owning module does. Inform Sema that this
557 // declaration might not be visible.
559 } else if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
560 if (Owner->NameVisibility != Module::AllVisible) {
561 // The owning module is not visible. Mark this declaration as hidden.
564 // Note that this declaration was hidden because its owning module is
566 Reader.HiddenNamesMap[Owner].push_back(D);
572 void ASTDeclReader::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
574 D->setLocation(ReadSourceLocation(Record, Idx));
575 D->CommentKind = (PragmaMSCommentKind)Record[Idx++];
576 std::string Arg = ReadString(Record, Idx);
577 memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());
578 D->getTrailingObjects<char>()[Arg.size()] = '\0';
581 void ASTDeclReader::VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) {
583 D->setLocation(ReadSourceLocation(Record, Idx));
584 std::string Name = ReadString(Record, Idx);
585 memcpy(D->getTrailingObjects<char>(), Name.data(), Name.size());
586 D->getTrailingObjects<char>()[Name.size()] = '\0';
588 D->ValueStart = Name.size() + 1;
589 std::string Value = ReadString(Record, Idx);
590 memcpy(D->getTrailingObjects<char>() + D->ValueStart, Value.data(),
592 D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';
595 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
596 llvm_unreachable("Translation units are not serialized");
599 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
601 ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
602 AnonymousDeclNumber = Record[Idx++];
605 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
607 TD->setLocStart(ReadSourceLocation(Record, Idx));
608 // Delay type reading until after we have fully initialized the decl.
609 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
612 ASTDeclReader::RedeclarableResult
613 ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
614 RedeclarableResult Redecl = VisitRedeclarable(TD);
616 TypeSourceInfo *TInfo = GetTypeSourceInfo(Record, Idx);
617 if (Record[Idx++]) { // isModed
618 QualType modedT = Reader.readType(F, Record, Idx);
619 TD->setModedTypeSourceInfo(TInfo, modedT);
621 TD->setTypeSourceInfo(TInfo);
625 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
626 RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
627 mergeRedeclarable(TD, Redecl);
630 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
631 RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
632 if (auto *Template = ReadDeclAs<TypeAliasTemplateDecl>(Record, Idx))
633 // Merged when we merge the template.
634 TD->setDescribedAliasTemplate(Template);
636 mergeRedeclarable(TD, Redecl);
639 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
640 RedeclarableResult Redecl = VisitRedeclarable(TD);
643 TD->IdentifierNamespace = Record[Idx++];
644 TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
645 if (!isa<CXXRecordDecl>(TD))
646 TD->setCompleteDefinition(Record[Idx++]);
647 TD->setEmbeddedInDeclarator(Record[Idx++]);
648 TD->setFreeStanding(Record[Idx++]);
649 TD->setCompleteDefinitionRequired(Record[Idx++]);
650 TD->setBraceRange(ReadSourceRange(Record, Idx));
652 switch (Record[Idx++]) {
656 TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
657 ReadQualifierInfo(*Info, Record, Idx);
658 TD->TypedefNameDeclOrQualifier = Info;
661 case 2: // TypedefNameForAnonDecl
662 NamedDeclForTagDecl = ReadDeclID(Record, Idx);
663 TypedefNameForLinkage = Reader.GetIdentifierInfo(F, Record, Idx);
666 llvm_unreachable("unexpected tag info kind");
669 if (!isa<CXXRecordDecl>(TD))
670 mergeRedeclarable(TD, Redecl);
674 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
676 if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
677 ED->setIntegerTypeSourceInfo(TI);
679 ED->setIntegerType(Reader.readType(F, Record, Idx));
680 ED->setPromotionType(Reader.readType(F, Record, Idx));
681 ED->setNumPositiveBits(Record[Idx++]);
682 ED->setNumNegativeBits(Record[Idx++]);
683 ED->IsScoped = Record[Idx++];
684 ED->IsScopedUsingClassTag = Record[Idx++];
685 ED->IsFixed = Record[Idx++];
687 // If this is a definition subject to the ODR, and we already have a
688 // definition, merge this one into it.
689 if (ED->IsCompleteDefinition &&
690 Reader.getContext().getLangOpts().Modules &&
691 Reader.getContext().getLangOpts().CPlusPlus) {
692 EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];
694 // This is the first time we've seen an imported definition. Look for a
695 // local definition before deciding that we are the first definition.
696 for (auto *D : merged_redecls(ED->getCanonicalDecl())) {
697 if (!D->isFromASTFile() && D->isCompleteDefinition()) {
704 Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
705 ED->IsCompleteDefinition = false;
706 mergeDefinitionVisibility(OldDef, ED);
712 if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
713 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
714 SourceLocation POI = ReadSourceLocation(Record, Idx);
715 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
716 ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
720 ASTDeclReader::RedeclarableResult
721 ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
722 RedeclarableResult Redecl = VisitTagDecl(RD);
723 RD->setHasFlexibleArrayMember(Record[Idx++]);
724 RD->setAnonymousStructOrUnion(Record[Idx++]);
725 RD->setHasObjectMember(Record[Idx++]);
726 RD->setHasVolatileMember(Record[Idx++]);
730 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
732 VD->setType(Reader.readType(F, Record, Idx));
735 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
738 ECD->setInitExpr(Reader.ReadExpr(F));
739 ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
743 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
745 DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
746 if (Record[Idx++]) { // hasExtInfo
747 DeclaratorDecl::ExtInfo *Info
748 = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
749 ReadQualifierInfo(*Info, Record, Idx);
754 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
755 RedeclarableResult Redecl = VisitRedeclarable(FD);
756 VisitDeclaratorDecl(FD);
758 ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
759 FD->IdentifierNamespace = Record[Idx++];
761 // FunctionDecl's body is handled last at ASTDeclReader::Visit,
762 // after everything else is read.
764 FD->SClass = (StorageClass)Record[Idx++];
765 FD->IsInline = Record[Idx++];
766 FD->IsInlineSpecified = Record[Idx++];
767 FD->IsVirtualAsWritten = Record[Idx++];
768 FD->IsPure = Record[Idx++];
769 FD->HasInheritedPrototype = Record[Idx++];
770 FD->HasWrittenPrototype = Record[Idx++];
771 FD->IsDeleted = Record[Idx++];
772 FD->IsTrivial = Record[Idx++];
773 FD->IsDefaulted = Record[Idx++];
774 FD->IsExplicitlyDefaulted = Record[Idx++];
775 FD->HasImplicitReturnZero = Record[Idx++];
776 FD->IsConstexpr = Record[Idx++];
777 FD->HasSkippedBody = Record[Idx++];
778 FD->IsLateTemplateParsed = Record[Idx++];
779 FD->setCachedLinkage(Linkage(Record[Idx++]));
780 FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
782 switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
783 case FunctionDecl::TK_NonTemplate:
784 mergeRedeclarable(FD, Redecl);
786 case FunctionDecl::TK_FunctionTemplate:
787 // Merged when we merge the template.
788 FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
791 case FunctionDecl::TK_MemberSpecialization: {
792 FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
793 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
794 SourceLocation POI = ReadSourceLocation(Record, Idx);
795 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
796 FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
797 mergeRedeclarable(FD, Redecl);
800 case FunctionDecl::TK_FunctionTemplateSpecialization: {
801 FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
803 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
805 // Template arguments.
806 SmallVector<TemplateArgument, 8> TemplArgs;
807 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
808 /*Canonicalize*/ true);
810 // Template args as written.
811 SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
812 SourceLocation LAngleLoc, RAngleLoc;
813 bool HasTemplateArgumentsAsWritten = Record[Idx++];
814 if (HasTemplateArgumentsAsWritten) {
815 unsigned NumTemplateArgLocs = Record[Idx++];
816 TemplArgLocs.reserve(NumTemplateArgLocs);
817 for (unsigned i=0; i != NumTemplateArgLocs; ++i)
818 TemplArgLocs.push_back(
819 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
821 LAngleLoc = ReadSourceLocation(Record, Idx);
822 RAngleLoc = ReadSourceLocation(Record, Idx);
825 SourceLocation POI = ReadSourceLocation(Record, Idx);
827 ASTContext &C = Reader.getContext();
828 TemplateArgumentList *TemplArgList
829 = TemplateArgumentList::CreateCopy(C, TemplArgs);
830 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
831 for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
832 TemplArgsInfo.addArgument(TemplArgLocs[i]);
833 FunctionTemplateSpecializationInfo *FTInfo
834 = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
836 HasTemplateArgumentsAsWritten ? &TemplArgsInfo
839 FD->TemplateOrSpecialization = FTInfo;
841 if (FD->isCanonicalDecl()) { // if canonical add to template's set.
842 // The template that contains the specializations set. It's not safe to
843 // use getCanonicalDecl on Template since it may still be initializing.
844 FunctionTemplateDecl *CanonTemplate
845 = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
846 // Get the InsertPos by FindNodeOrInsertPos() instead of calling
847 // InsertNode(FTInfo) directly to avoid the getASTContext() call in
848 // FunctionTemplateSpecializationInfo's Profile().
849 // We avoid getASTContext because a decl in the parent hierarchy may
851 llvm::FoldingSetNodeID ID;
852 FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C);
853 void *InsertPos = nullptr;
854 FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
855 FunctionTemplateSpecializationInfo *ExistingInfo =
856 CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
858 CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
860 assert(Reader.getContext().getLangOpts().Modules &&
861 "already deserialized this template specialization");
862 mergeRedeclarable(FD, ExistingInfo->Function, Redecl);
867 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
869 UnresolvedSet<8> TemplDecls;
870 unsigned NumTemplates = Record[Idx++];
871 while (NumTemplates--)
872 TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
875 TemplateArgumentListInfo TemplArgs;
876 unsigned NumArgs = Record[Idx++];
878 TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
879 TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
880 TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
882 FD->setDependentTemplateSpecialization(Reader.getContext(),
883 TemplDecls, TemplArgs);
884 // These are not merged; we don't need to merge redeclarations of dependent
890 // Read in the parameters.
891 unsigned NumParams = Record[Idx++];
892 SmallVector<ParmVarDecl *, 16> Params;
893 Params.reserve(NumParams);
894 for (unsigned I = 0; I != NumParams; ++I)
895 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
896 FD->setParams(Reader.getContext(), Params);
899 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
902 // Load the body on-demand. Most clients won't care, because method
903 // definitions rarely show up in headers.
904 Reader.PendingBodies[MD] = GetCurrentCursorOffset();
905 HasPendingBody = true;
906 MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
907 MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
909 MD->setInstanceMethod(Record[Idx++]);
910 MD->setVariadic(Record[Idx++]);
911 MD->setPropertyAccessor(Record[Idx++]);
912 MD->setDefined(Record[Idx++]);
913 MD->IsOverriding = Record[Idx++];
914 MD->HasSkippedBody = Record[Idx++];
916 MD->IsRedeclaration = Record[Idx++];
917 MD->HasRedeclaration = Record[Idx++];
918 if (MD->HasRedeclaration)
919 Reader.getContext().setObjCMethodRedeclaration(MD,
920 ReadDeclAs<ObjCMethodDecl>(Record, Idx));
922 MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
923 MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
924 MD->SetRelatedResultType(Record[Idx++]);
925 MD->setReturnType(Reader.readType(F, Record, Idx));
926 MD->setReturnTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
927 MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
928 unsigned NumParams = Record[Idx++];
929 SmallVector<ParmVarDecl *, 16> Params;
930 Params.reserve(NumParams);
931 for (unsigned I = 0; I != NumParams; ++I)
932 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
934 MD->SelLocsKind = Record[Idx++];
935 unsigned NumStoredSelLocs = Record[Idx++];
936 SmallVector<SourceLocation, 16> SelLocs;
937 SelLocs.reserve(NumStoredSelLocs);
938 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
939 SelLocs.push_back(ReadSourceLocation(Record, Idx));
941 MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
944 void ASTDeclReader::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
945 VisitTypedefNameDecl(D);
947 D->Variance = Record[Idx++];
948 D->Index = Record[Idx++];
949 D->VarianceLoc = ReadSourceLocation(Record, Idx);
950 D->ColonLoc = ReadSourceLocation(Record, Idx);
953 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
955 CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
956 CD->setAtEndRange(ReadSourceRange(Record, Idx));
959 ObjCTypeParamList *ASTDeclReader::ReadObjCTypeParamList() {
960 unsigned numParams = Record[Idx++];
964 SmallVector<ObjCTypeParamDecl *, 4> typeParams;
965 typeParams.reserve(numParams);
966 for (unsigned i = 0; i != numParams; ++i) {
967 auto typeParam = ReadDeclAs<ObjCTypeParamDecl>(Record, Idx);
971 typeParams.push_back(typeParam);
974 SourceLocation lAngleLoc = ReadSourceLocation(Record, Idx);
975 SourceLocation rAngleLoc = ReadSourceLocation(Record, Idx);
977 return ObjCTypeParamList::create(Reader.getContext(), lAngleLoc,
978 typeParams, rAngleLoc);
981 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
982 RedeclarableResult Redecl = VisitRedeclarable(ID);
983 VisitObjCContainerDecl(ID);
984 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
985 mergeRedeclarable(ID, Redecl);
987 ID->TypeParamList = ReadObjCTypeParamList();
989 // Read the definition.
990 ID->allocateDefinitionData();
992 // Set the definition data of the canonical declaration, so other
993 // redeclarations will see it.
994 ID->getCanonicalDecl()->Data = ID->Data;
996 ObjCInterfaceDecl::DefinitionData &Data = ID->data();
998 // Read the superclass.
999 Data.SuperClassTInfo = GetTypeSourceInfo(Record, Idx);
1001 Data.EndLoc = ReadSourceLocation(Record, Idx);
1002 Data.HasDesignatedInitializers = Record[Idx++];
1004 // Read the directly referenced protocols and their SourceLocations.
1005 unsigned NumProtocols = Record[Idx++];
1006 SmallVector<ObjCProtocolDecl *, 16> Protocols;
1007 Protocols.reserve(NumProtocols);
1008 for (unsigned I = 0; I != NumProtocols; ++I)
1009 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1010 SmallVector<SourceLocation, 16> ProtoLocs;
1011 ProtoLocs.reserve(NumProtocols);
1012 for (unsigned I = 0; I != NumProtocols; ++I)
1013 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
1014 ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
1015 Reader.getContext());
1017 // Read the transitive closure of protocols referenced by this class.
1018 NumProtocols = Record[Idx++];
1020 Protocols.reserve(NumProtocols);
1021 for (unsigned I = 0; I != NumProtocols; ++I)
1022 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1023 ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
1024 Reader.getContext());
1026 // We will rebuild this list lazily.
1027 ID->setIvarList(nullptr);
1029 // Note that we have deserialized a definition.
1030 Reader.PendingDefinitions.insert(ID);
1032 // Note that we've loaded this Objective-C class.
1033 Reader.ObjCClassesLoaded.push_back(ID);
1035 ID->Data = ID->getCanonicalDecl()->Data;
1039 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
1040 VisitFieldDecl(IVD);
1041 IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
1042 // This field will be built lazily.
1043 IVD->setNextIvar(nullptr);
1044 bool synth = Record[Idx++];
1045 IVD->setSynthesize(synth);
1048 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
1049 RedeclarableResult Redecl = VisitRedeclarable(PD);
1050 VisitObjCContainerDecl(PD);
1051 mergeRedeclarable(PD, Redecl);
1053 if (Record[Idx++]) {
1054 // Read the definition.
1055 PD->allocateDefinitionData();
1057 // Set the definition data of the canonical declaration, so other
1058 // redeclarations will see it.
1059 PD->getCanonicalDecl()->Data = PD->Data;
1061 unsigned NumProtoRefs = Record[Idx++];
1062 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
1063 ProtoRefs.reserve(NumProtoRefs);
1064 for (unsigned I = 0; I != NumProtoRefs; ++I)
1065 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1066 SmallVector<SourceLocation, 16> ProtoLocs;
1067 ProtoLocs.reserve(NumProtoRefs);
1068 for (unsigned I = 0; I != NumProtoRefs; ++I)
1069 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
1070 PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
1071 Reader.getContext());
1073 // Note that we have deserialized a definition.
1074 Reader.PendingDefinitions.insert(PD);
1076 PD->Data = PD->getCanonicalDecl()->Data;
1080 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
1084 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
1085 VisitObjCContainerDecl(CD);
1086 CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
1087 CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
1088 CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
1090 // Note that this category has been deserialized. We do this before
1091 // deserializing the interface declaration, so that it will consider this
1093 Reader.CategoriesDeserialized.insert(CD);
1095 CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
1096 CD->TypeParamList = ReadObjCTypeParamList();
1097 unsigned NumProtoRefs = Record[Idx++];
1098 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
1099 ProtoRefs.reserve(NumProtoRefs);
1100 for (unsigned I = 0; I != NumProtoRefs; ++I)
1101 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1102 SmallVector<SourceLocation, 16> ProtoLocs;
1103 ProtoLocs.reserve(NumProtoRefs);
1104 for (unsigned I = 0; I != NumProtoRefs; ++I)
1105 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
1106 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
1107 Reader.getContext());
1110 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
1111 VisitNamedDecl(CAD);
1112 CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1115 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
1117 D->setAtLoc(ReadSourceLocation(Record, Idx));
1118 D->setLParenLoc(ReadSourceLocation(Record, Idx));
1119 QualType T = Reader.readType(F, Record, Idx);
1120 TypeSourceInfo *TSI = GetTypeSourceInfo(Record, Idx);
1122 D->setPropertyAttributes(
1123 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
1124 D->setPropertyAttributesAsWritten(
1125 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
1126 D->setPropertyImplementation(
1127 (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
1128 D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
1129 D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
1130 D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1131 D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1132 D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
1135 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
1136 VisitObjCContainerDecl(D);
1137 D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1140 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1141 VisitObjCImplDecl(D);
1142 D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
1143 D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
1146 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1147 VisitObjCImplDecl(D);
1148 D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1149 D->SuperLoc = ReadSourceLocation(Record, Idx);
1150 D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
1151 D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
1152 D->setHasNonZeroConstructors(Record[Idx++]);
1153 D->setHasDestructors(Record[Idx++]);
1154 D->NumIvarInitializers = Record[Idx++];
1155 if (D->NumIvarInitializers)
1156 D->IvarInitializers = ReadGlobalOffset(F, Record, Idx);
1159 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
1161 D->setAtLoc(ReadSourceLocation(Record, Idx));
1162 D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
1163 D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
1164 D->IvarLoc = ReadSourceLocation(Record, Idx);
1165 D->setGetterCXXConstructor(Reader.ReadExpr(F));
1166 D->setSetterCXXAssignment(Reader.ReadExpr(F));
1169 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
1170 VisitDeclaratorDecl(FD);
1171 FD->Mutable = Record[Idx++];
1172 if (int BitWidthOrInitializer = Record[Idx++]) {
1173 FD->InitStorage.setInt(
1174 static_cast<FieldDecl::InitStorageKind>(BitWidthOrInitializer - 1));
1175 if (FD->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) {
1176 // Read captured variable length array.
1177 FD->InitStorage.setPointer(
1178 Reader.readType(F, Record, Idx).getAsOpaquePtr());
1180 FD->InitStorage.setPointer(Reader.ReadExpr(F));
1183 if (!FD->getDeclName()) {
1184 if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
1185 Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
1190 void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
1191 VisitDeclaratorDecl(PD);
1192 PD->GetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1193 PD->SetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1196 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
1199 FD->ChainingSize = Record[Idx++];
1200 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1201 FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
1203 for (unsigned I = 0; I != FD->ChainingSize; ++I)
1204 FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
1209 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
1210 RedeclarableResult Redecl = VisitRedeclarable(VD);
1211 VisitDeclaratorDecl(VD);
1213 VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
1214 VD->VarDeclBits.TSCSpec = Record[Idx++];
1215 VD->VarDeclBits.InitStyle = Record[Idx++];
1216 if (!isa<ParmVarDecl>(VD)) {
1217 VD->NonParmVarDeclBits.ExceptionVar = Record[Idx++];
1218 VD->NonParmVarDeclBits.NRVOVariable = Record[Idx++];
1219 VD->NonParmVarDeclBits.CXXForRangeDecl = Record[Idx++];
1220 VD->NonParmVarDeclBits.ARCPseudoStrong = Record[Idx++];
1221 VD->NonParmVarDeclBits.IsInline = Record[Idx++];
1222 VD->NonParmVarDeclBits.IsInlineSpecified = Record[Idx++];
1223 VD->NonParmVarDeclBits.IsConstexpr = Record[Idx++];
1224 VD->NonParmVarDeclBits.IsInitCapture = Record[Idx++];
1225 VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
1227 Linkage VarLinkage = Linkage(Record[Idx++]);
1228 VD->setCachedLinkage(VarLinkage);
1230 // Reconstruct the one piece of the IdentifierNamespace that we need.
1231 if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
1232 VD->getLexicalDeclContext()->isFunctionOrMethod())
1233 VD->setLocalExternDecl();
1235 if (uint64_t Val = Record[Idx++]) {
1236 VD->setInit(Reader.ReadExpr(F));
1238 EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1239 Eval->CheckedICE = true;
1240 Eval->IsICE = Val == 3;
1245 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1247 switch ((VarKind)Record[Idx++]) {
1248 case VarNotTemplate:
1249 // Only true variables (not parameters or implicit parameters) can be
1250 // merged; the other kinds are not really redeclarable at all.
1251 if (!isa<ParmVarDecl>(VD) && !isa<ImplicitParamDecl>(VD) &&
1252 !isa<VarTemplateSpecializationDecl>(VD))
1253 mergeRedeclarable(VD, Redecl);
1256 // Merged when we merge the template.
1257 VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
1259 case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
1260 VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
1261 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1262 SourceLocation POI = ReadSourceLocation(Record, Idx);
1263 Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
1264 mergeRedeclarable(VD, Redecl);
1272 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
1276 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
1278 unsigned isObjCMethodParam = Record[Idx++];
1279 unsigned scopeDepth = Record[Idx++];
1280 unsigned scopeIndex = Record[Idx++];
1281 unsigned declQualifier = Record[Idx++];
1282 if (isObjCMethodParam) {
1283 assert(scopeDepth == 0);
1284 PD->setObjCMethodScopeInfo(scopeIndex);
1285 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1287 PD->setScopeInfo(scopeDepth, scopeIndex);
1289 PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
1290 PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
1291 if (Record[Idx++]) // hasUninstantiatedDefaultArg.
1292 PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
1294 // FIXME: If this is a redeclaration of a function from another module, handle
1295 // inheritance of default arguments.
1298 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
1300 AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
1301 AD->setRParenLoc(ReadSourceLocation(Record, Idx));
1304 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
1306 BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
1307 BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
1308 unsigned NumParams = Record[Idx++];
1309 SmallVector<ParmVarDecl *, 16> Params;
1310 Params.reserve(NumParams);
1311 for (unsigned I = 0; I != NumParams; ++I)
1312 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
1313 BD->setParams(Params);
1315 BD->setIsVariadic(Record[Idx++]);
1316 BD->setBlockMissingReturnType(Record[Idx++]);
1317 BD->setIsConversionFromLambda(Record[Idx++]);
1319 bool capturesCXXThis = Record[Idx++];
1320 unsigned numCaptures = Record[Idx++];
1321 SmallVector<BlockDecl::Capture, 16> captures;
1322 captures.reserve(numCaptures);
1323 for (unsigned i = 0; i != numCaptures; ++i) {
1324 VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
1325 unsigned flags = Record[Idx++];
1326 bool byRef = (flags & 1);
1327 bool nested = (flags & 2);
1328 Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr);
1330 captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
1332 BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);
1335 void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
1337 unsigned ContextParamPos = Record[Idx++];
1338 CD->setNothrow(Record[Idx++] != 0);
1339 // Body is set by VisitCapturedStmt.
1340 for (unsigned I = 0; I < CD->NumParams; ++I) {
1341 if (I != ContextParamPos)
1342 CD->setParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1344 CD->setContextParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1348 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1350 D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
1351 D->setExternLoc(ReadSourceLocation(Record, Idx));
1352 D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1355 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1357 D->setLocStart(ReadSourceLocation(Record, Idx));
1360 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1361 RedeclarableResult Redecl = VisitRedeclarable(D);
1363 D->setInline(Record[Idx++]);
1364 D->LocStart = ReadSourceLocation(Record, Idx);
1365 D->RBraceLoc = ReadSourceLocation(Record, Idx);
1367 // Defer loading the anonymous namespace until we've finished merging
1368 // this namespace; loading it might load a later declaration of the
1369 // same namespace, and we have an invariant that older declarations
1370 // get merged before newer ones try to merge.
1371 GlobalDeclID AnonNamespace = 0;
1372 if (Redecl.getFirstID() == ThisDeclID) {
1373 AnonNamespace = ReadDeclID(Record, Idx);
1375 // Link this namespace back to the first declaration, which has already
1376 // been deserialized.
1377 D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
1380 mergeRedeclarable(D, Redecl);
1382 if (AnonNamespace) {
1383 // Each module has its own anonymous namespace, which is disjoint from
1384 // any other module's anonymous namespaces, so don't attach the anonymous
1385 // namespace at all.
1386 NamespaceDecl *Anon = cast<NamespaceDecl>(Reader.GetDecl(AnonNamespace));
1387 if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule)
1388 D->setAnonymousNamespace(Anon);
1392 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1393 RedeclarableResult Redecl = VisitRedeclarable(D);
1395 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1396 D->IdentLoc = ReadSourceLocation(Record, Idx);
1397 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1398 D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1399 mergeRedeclarable(D, Redecl);
1402 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1404 D->setUsingLoc(ReadSourceLocation(Record, Idx));
1405 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1406 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1407 D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1408 D->setTypename(Record[Idx++]);
1409 if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1410 Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1414 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1415 RedeclarableResult Redecl = VisitRedeclarable(D);
1417 D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1418 D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1419 UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1421 Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1422 mergeRedeclarable(D, Redecl);
1425 void ASTDeclReader::VisitConstructorUsingShadowDecl(
1426 ConstructorUsingShadowDecl *D) {
1427 VisitUsingShadowDecl(D);
1428 D->NominatedBaseClassShadowDecl =
1429 ReadDeclAs<ConstructorUsingShadowDecl>(Record, Idx);
1430 D->ConstructedBaseClassShadowDecl =
1431 ReadDeclAs<ConstructorUsingShadowDecl>(Record, Idx);
1432 D->IsVirtual = Record[Idx++];
1435 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1437 D->UsingLoc = ReadSourceLocation(Record, Idx);
1438 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1439 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1440 D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1441 D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1444 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1446 D->setUsingLoc(ReadSourceLocation(Record, Idx));
1447 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1448 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1452 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1453 UnresolvedUsingTypenameDecl *D) {
1455 D->TypenameLocation = ReadSourceLocation(Record, Idx);
1456 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1460 void ASTDeclReader::ReadCXXDefinitionData(
1461 struct CXXRecordDecl::DefinitionData &Data,
1462 const RecordData &Record, unsigned &Idx) {
1463 // Note: the caller has deserialized the IsLambda bit already.
1464 Data.UserDeclaredConstructor = Record[Idx++];
1465 Data.UserDeclaredSpecialMembers = Record[Idx++];
1466 Data.Aggregate = Record[Idx++];
1467 Data.PlainOldData = Record[Idx++];
1468 Data.Empty = Record[Idx++];
1469 Data.Polymorphic = Record[Idx++];
1470 Data.Abstract = Record[Idx++];
1471 Data.IsStandardLayout = Record[Idx++];
1472 Data.HasNoNonEmptyBases = Record[Idx++];
1473 Data.HasPrivateFields = Record[Idx++];
1474 Data.HasProtectedFields = Record[Idx++];
1475 Data.HasPublicFields = Record[Idx++];
1476 Data.HasMutableFields = Record[Idx++];
1477 Data.HasVariantMembers = Record[Idx++];
1478 Data.HasOnlyCMembers = Record[Idx++];
1479 Data.HasInClassInitializer = Record[Idx++];
1480 Data.HasUninitializedReferenceMember = Record[Idx++];
1481 Data.HasUninitializedFields = Record[Idx++];
1482 Data.HasInheritedConstructor = Record[Idx++];
1483 Data.HasInheritedAssignment = Record[Idx++];
1484 Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
1485 Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
1486 Data.NeedOverloadResolutionForDestructor = Record[Idx++];
1487 Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
1488 Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
1489 Data.DefaultedDestructorIsDeleted = Record[Idx++];
1490 Data.HasTrivialSpecialMembers = Record[Idx++];
1491 Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
1492 Data.HasIrrelevantDestructor = Record[Idx++];
1493 Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1494 Data.HasDefaultedDefaultConstructor = Record[Idx++];
1495 Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1496 Data.HasConstexprDefaultConstructor = Record[Idx++];
1497 Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1498 Data.ComputedVisibleConversions = Record[Idx++];
1499 Data.UserProvidedDefaultConstructor = Record[Idx++];
1500 Data.DeclaredSpecialMembers = Record[Idx++];
1501 Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
1502 Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
1503 Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
1504 Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
1506 Data.NumBases = Record[Idx++];
1508 Data.Bases = ReadGlobalOffset(F, Record, Idx);
1509 Data.NumVBases = Record[Idx++];
1511 Data.VBases = ReadGlobalOffset(F, Record, Idx);
1513 Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1514 Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1515 assert(Data.Definition && "Data.Definition should be already set!");
1516 Data.FirstFriend = ReadDeclID(Record, Idx);
1518 if (Data.IsLambda) {
1519 typedef LambdaCapture Capture;
1520 CXXRecordDecl::LambdaDefinitionData &Lambda
1521 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1522 Lambda.Dependent = Record[Idx++];
1523 Lambda.IsGenericLambda = Record[Idx++];
1524 Lambda.CaptureDefault = Record[Idx++];
1525 Lambda.NumCaptures = Record[Idx++];
1526 Lambda.NumExplicitCaptures = Record[Idx++];
1527 Lambda.ManglingNumber = Record[Idx++];
1528 Lambda.ContextDecl = ReadDecl(Record, Idx);
1530 = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1531 Capture *ToCapture = Lambda.Captures;
1532 Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1533 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1534 SourceLocation Loc = ReadSourceLocation(Record, Idx);
1535 bool IsImplicit = Record[Idx++];
1536 LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1541 *ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
1545 VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1546 SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1547 *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1554 void ASTDeclReader::MergeDefinitionData(
1555 CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {
1556 assert(D->DefinitionData &&
1557 "merging class definition into non-definition");
1558 auto &DD = *D->DefinitionData;
1560 if (DD.Definition != MergeDD.Definition) {
1561 // Track that we merged the definitions.
1562 Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,
1564 Reader.PendingDefinitions.erase(MergeDD.Definition);
1565 MergeDD.Definition->IsCompleteDefinition = false;
1566 mergeDefinitionVisibility(DD.Definition, MergeDD.Definition);
1567 assert(Reader.Lookups.find(MergeDD.Definition) == Reader.Lookups.end() &&
1568 "already loaded pending lookups for merged definition");
1571 auto PFDI = Reader.PendingFakeDefinitionData.find(&DD);
1572 if (PFDI != Reader.PendingFakeDefinitionData.end() &&
1573 PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {
1574 // We faked up this definition data because we found a class for which we'd
1575 // not yet loaded the definition. Replace it with the real thing now.
1576 assert(!DD.IsLambda && !MergeDD.IsLambda && "faked up lambda definition?");
1577 PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;
1579 // Don't change which declaration is the definition; that is required
1580 // to be invariant once we select it.
1581 auto *Def = DD.Definition;
1582 DD = std::move(MergeDD);
1583 DD.Definition = Def;
1587 // FIXME: Move this out into a .def file?
1588 bool DetectedOdrViolation = false;
1589 #define OR_FIELD(Field) DD.Field |= MergeDD.Field;
1590 #define MATCH_FIELD(Field) \
1591 DetectedOdrViolation |= DD.Field != MergeDD.Field; \
1593 MATCH_FIELD(UserDeclaredConstructor)
1594 MATCH_FIELD(UserDeclaredSpecialMembers)
1595 MATCH_FIELD(Aggregate)
1596 MATCH_FIELD(PlainOldData)
1598 MATCH_FIELD(Polymorphic)
1599 MATCH_FIELD(Abstract)
1600 MATCH_FIELD(IsStandardLayout)
1601 MATCH_FIELD(HasNoNonEmptyBases)
1602 MATCH_FIELD(HasPrivateFields)
1603 MATCH_FIELD(HasProtectedFields)
1604 MATCH_FIELD(HasPublicFields)
1605 MATCH_FIELD(HasMutableFields)
1606 MATCH_FIELD(HasVariantMembers)
1607 MATCH_FIELD(HasOnlyCMembers)
1608 MATCH_FIELD(HasInClassInitializer)
1609 MATCH_FIELD(HasUninitializedReferenceMember)
1610 MATCH_FIELD(HasUninitializedFields)
1611 MATCH_FIELD(HasInheritedConstructor)
1612 MATCH_FIELD(HasInheritedAssignment)
1613 MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
1614 MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
1615 MATCH_FIELD(NeedOverloadResolutionForDestructor)
1616 MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
1617 MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
1618 MATCH_FIELD(DefaultedDestructorIsDeleted)
1619 OR_FIELD(HasTrivialSpecialMembers)
1620 OR_FIELD(DeclaredNonTrivialSpecialMembers)
1621 MATCH_FIELD(HasIrrelevantDestructor)
1622 OR_FIELD(HasConstexprNonCopyMoveConstructor)
1623 OR_FIELD(HasDefaultedDefaultConstructor)
1624 MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
1625 OR_FIELD(HasConstexprDefaultConstructor)
1626 MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
1627 // ComputedVisibleConversions is handled below.
1628 MATCH_FIELD(UserProvidedDefaultConstructor)
1629 OR_FIELD(DeclaredSpecialMembers)
1630 MATCH_FIELD(ImplicitCopyConstructorHasConstParam)
1631 MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
1632 OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
1633 OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
1634 MATCH_FIELD(IsLambda)
1638 if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
1639 DetectedOdrViolation = true;
1640 // FIXME: Issue a diagnostic if the base classes don't match when we come
1641 // to lazily load them.
1643 // FIXME: Issue a diagnostic if the list of conversion functions doesn't
1644 // match when we come to lazily load them.
1645 if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
1646 DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
1647 DD.ComputedVisibleConversions = true;
1650 // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
1654 // FIXME: ODR-checking for merging lambdas (this happens, for instance,
1655 // when they occur within the body of a function template specialization).
1658 if (DetectedOdrViolation)
1659 Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
1662 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update) {
1663 struct CXXRecordDecl::DefinitionData *DD;
1664 ASTContext &C = Reader.getContext();
1666 // Determine whether this is a lambda closure type, so that we can
1667 // allocate the appropriate DefinitionData structure.
1668 bool IsLambda = Record[Idx++];
1670 DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
1673 DD = new (C) struct CXXRecordDecl::DefinitionData(D);
1675 ReadCXXDefinitionData(*DD, Record, Idx);
1677 // We might already have a definition for this record. This can happen either
1678 // because we're reading an update record, or because we've already done some
1679 // merging. Either way, just merge into it.
1680 CXXRecordDecl *Canon = D->getCanonicalDecl();
1681 if (Canon->DefinitionData) {
1682 MergeDefinitionData(Canon, std::move(*DD));
1683 D->DefinitionData = Canon->DefinitionData;
1687 // Mark this declaration as being a definition.
1688 D->IsCompleteDefinition = true;
1689 D->DefinitionData = DD;
1691 // If this is not the first declaration or is an update record, we can have
1692 // other redeclarations already. Make a note that we need to propagate the
1693 // DefinitionData pointer onto them.
1694 if (Update || Canon != D) {
1695 Canon->DefinitionData = D->DefinitionData;
1696 Reader.PendingDefinitions.insert(D);
1700 ASTDeclReader::RedeclarableResult
1701 ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
1702 RedeclarableResult Redecl = VisitRecordDeclImpl(D);
1704 ASTContext &C = Reader.getContext();
1707 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1709 switch ((CXXRecKind)Record[Idx++]) {
1710 case CXXRecNotTemplate:
1711 // Merged when we merge the folding set entry in the primary template.
1712 if (!isa<ClassTemplateSpecializationDecl>(D))
1713 mergeRedeclarable(D, Redecl);
1715 case CXXRecTemplate: {
1716 // Merged when we merge the template.
1717 ClassTemplateDecl *Template = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1718 D->TemplateOrInstantiation = Template;
1719 if (!Template->getTemplatedDecl()) {
1720 // We've not actually loaded the ClassTemplateDecl yet, because we're
1721 // currently being loaded as its pattern. Rely on it to set up our
1722 // TypeForDecl (see VisitClassTemplateDecl).
1724 // Beware: we do not yet know our canonical declaration, and may still
1725 // get merged once the surrounding class template has got off the ground.
1726 TypeIDForTypeDecl = 0;
1730 case CXXRecMemberSpecialization: {
1731 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1732 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1733 SourceLocation POI = ReadSourceLocation(Record, Idx);
1734 MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1735 MSI->setPointOfInstantiation(POI);
1736 D->TemplateOrInstantiation = MSI;
1737 mergeRedeclarable(D, Redecl);
1742 bool WasDefinition = Record[Idx++];
1744 ReadCXXRecordDefinition(D, /*Update*/false);
1746 // Propagate DefinitionData pointer from the canonical declaration.
1747 D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1749 // Lazily load the key function to avoid deserializing every method so we can
1751 if (WasDefinition) {
1752 DeclID KeyFn = ReadDeclID(Record, Idx);
1753 if (KeyFn && D->IsCompleteDefinition)
1754 // FIXME: This is wrong for the ARM ABI, where some other module may have
1755 // made this function no longer be a key function. We need an update
1756 // record or similar for that case.
1757 C.KeyFunctions[D] = KeyFn;
1763 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1764 VisitFunctionDecl(D);
1766 unsigned NumOverridenMethods = Record[Idx++];
1767 if (D->isCanonicalDecl()) {
1768 while (NumOverridenMethods--) {
1769 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1770 // MD may be initializing.
1771 if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1772 Reader.getContext().addOverriddenMethod(D, MD->getCanonicalDecl());
1775 // We don't care about which declarations this used to override; we get
1776 // the relevant information from the canonical declaration.
1777 Idx += NumOverridenMethods;
1781 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1782 // We need the inherited constructor information to merge the declaration,
1783 // so we have to read it before we call VisitCXXMethodDecl.
1784 if (D->isInheritingConstructor()) {
1785 auto *Shadow = ReadDeclAs<ConstructorUsingShadowDecl>(Record, Idx);
1786 auto *Ctor = ReadDeclAs<CXXConstructorDecl>(Record, Idx);
1787 *D->getTrailingObjects<InheritedConstructor>() =
1788 InheritedConstructor(Shadow, Ctor);
1791 VisitCXXMethodDecl(D);
1793 D->IsExplicitSpecified = Record[Idx++];
1796 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1797 VisitCXXMethodDecl(D);
1799 if (auto *OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx)) {
1800 auto *Canon = cast<CXXDestructorDecl>(D->getCanonicalDecl());
1801 // FIXME: Check consistency if we have an old and new operator delete.
1802 if (!Canon->OperatorDelete)
1803 Canon->OperatorDelete = OperatorDelete;
1807 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1808 VisitCXXMethodDecl(D);
1809 D->IsExplicitSpecified = Record[Idx++];
1812 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1814 D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1815 D->ImportedAndComplete.setInt(Record[Idx++]);
1816 SourceLocation *StoredLocs = D->getTrailingObjects<SourceLocation>();
1817 for (unsigned I = 0, N = Record.back(); I != N; ++I)
1818 StoredLocs[I] = ReadSourceLocation(Record, Idx);
1819 ++Idx; // The number of stored source locations.
1822 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1824 D->setColonLoc(ReadSourceLocation(Record, Idx));
1827 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1829 if (Record[Idx++]) // hasFriendDecl
1830 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1832 D->Friend = GetTypeSourceInfo(Record, Idx);
1833 for (unsigned i = 0; i != D->NumTPLists; ++i)
1834 D->getTrailingObjects<TemplateParameterList *>()[i] =
1835 Reader.ReadTemplateParameterList(F, Record, Idx);
1836 D->NextFriend = ReadDeclID(Record, Idx);
1837 D->UnsupportedFriend = (Record[Idx++] != 0);
1838 D->FriendLoc = ReadSourceLocation(Record, Idx);
1841 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1843 unsigned NumParams = Record[Idx++];
1844 D->NumParams = NumParams;
1845 D->Params = new TemplateParameterList*[NumParams];
1846 for (unsigned i = 0; i != NumParams; ++i)
1847 D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1848 if (Record[Idx++]) // HasFriendDecl
1849 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1851 D->Friend = GetTypeSourceInfo(Record, Idx);
1852 D->FriendLoc = ReadSourceLocation(Record, Idx);
1855 DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1858 DeclID PatternID = ReadDeclID(Record, Idx);
1859 NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
1860 TemplateParameterList* TemplateParams
1861 = Reader.ReadTemplateParameterList(F, Record, Idx);
1862 D->init(TemplatedDecl, TemplateParams);
1867 ASTDeclReader::RedeclarableResult
1868 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1869 RedeclarableResult Redecl = VisitRedeclarable(D);
1871 // Make sure we've allocated the Common pointer first. We do this before
1872 // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1873 RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1874 if (!CanonD->Common) {
1875 CanonD->Common = CanonD->newCommon(Reader.getContext());
1876 Reader.PendingDefinitions.insert(CanonD);
1878 D->Common = CanonD->Common;
1880 // If this is the first declaration of the template, fill in the information
1881 // for the 'common' pointer.
1882 if (ThisDeclID == Redecl.getFirstID()) {
1883 if (RedeclarableTemplateDecl *RTD
1884 = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1885 assert(RTD->getKind() == D->getKind() &&
1886 "InstantiatedFromMemberTemplate kind mismatch");
1887 D->setInstantiatedFromMemberTemplate(RTD);
1889 D->setMemberSpecialization();
1893 DeclID PatternID = VisitTemplateDecl(D);
1894 D->IdentifierNamespace = Record[Idx++];
1896 mergeRedeclarable(D, Redecl, PatternID);
1898 // If we merged the template with a prior declaration chain, merge the common
1900 // FIXME: Actually merge here, don't just overwrite.
1901 D->Common = D->getCanonicalDecl()->Common;
1906 static DeclID *newDeclIDList(ASTContext &Context, DeclID *Old,
1907 SmallVectorImpl<DeclID> &IDs) {
1908 assert(!IDs.empty() && "no IDs to add to list");
1910 IDs.insert(IDs.end(), Old + 1, Old + 1 + Old[0]);
1911 std::sort(IDs.begin(), IDs.end());
1912 IDs.erase(std::unique(IDs.begin(), IDs.end()), IDs.end());
1915 auto *Result = new (Context) DeclID[1 + IDs.size()];
1916 *Result = IDs.size();
1917 std::copy(IDs.begin(), IDs.end(), Result + 1);
1921 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1922 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1924 if (ThisDeclID == Redecl.getFirstID()) {
1925 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1926 // the specializations.
1927 SmallVector<serialization::DeclID, 32> SpecIDs;
1928 ReadDeclIDList(SpecIDs);
1930 if (!SpecIDs.empty()) {
1931 auto *CommonPtr = D->getCommonPtr();
1932 CommonPtr->LazySpecializations = newDeclIDList(
1933 Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
1937 if (D->getTemplatedDecl()->TemplateOrInstantiation) {
1938 // We were loaded before our templated declaration was. We've not set up
1939 // its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
1941 Reader.Context.getInjectedClassNameType(
1942 D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
1946 void ASTDeclReader::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
1947 llvm_unreachable("BuiltinTemplates are not serialized");
1950 /// TODO: Unify with ClassTemplateDecl version?
1951 /// May require unifying ClassTemplateDecl and
1952 /// VarTemplateDecl beyond TemplateDecl...
1953 void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
1954 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1956 if (ThisDeclID == Redecl.getFirstID()) {
1957 // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
1958 // the specializations.
1959 SmallVector<serialization::DeclID, 32> SpecIDs;
1960 ReadDeclIDList(SpecIDs);
1962 if (!SpecIDs.empty()) {
1963 auto *CommonPtr = D->getCommonPtr();
1964 CommonPtr->LazySpecializations = newDeclIDList(
1965 Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
1970 ASTDeclReader::RedeclarableResult
1971 ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
1972 ClassTemplateSpecializationDecl *D) {
1973 RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
1975 ASTContext &C = Reader.getContext();
1976 if (Decl *InstD = ReadDecl(Record, Idx)) {
1977 if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1978 D->SpecializedTemplate = CTD;
1980 SmallVector<TemplateArgument, 8> TemplArgs;
1981 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1982 TemplateArgumentList *ArgList
1983 = TemplateArgumentList::CreateCopy(C, TemplArgs);
1984 ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1985 = new (C) ClassTemplateSpecializationDecl::
1986 SpecializedPartialSpecialization();
1987 PS->PartialSpecialization
1988 = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1989 PS->TemplateArgs = ArgList;
1990 D->SpecializedTemplate = PS;
1994 SmallVector<TemplateArgument, 8> TemplArgs;
1995 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
1996 /*Canonicalize*/ true);
1997 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
1998 D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1999 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
2001 bool writtenAsCanonicalDecl = Record[Idx++];
2002 if (writtenAsCanonicalDecl) {
2003 ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
2004 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2005 // Set this as, or find, the canonical declaration for this specialization
2006 ClassTemplateSpecializationDecl *CanonSpec;
2007 if (ClassTemplatePartialSpecializationDecl *Partial =
2008 dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
2009 CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
2010 .GetOrInsertNode(Partial);
2013 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2015 // If there was already a canonical specialization, merge into it.
2016 if (CanonSpec != D) {
2017 mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
2019 // This declaration might be a definition. Merge with any existing
2021 if (auto *DDD = D->DefinitionData) {
2022 if (CanonSpec->DefinitionData)
2023 MergeDefinitionData(CanonSpec, std::move(*DDD));
2025 CanonSpec->DefinitionData = D->DefinitionData;
2027 D->DefinitionData = CanonSpec->DefinitionData;
2033 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
2034 ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
2035 = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
2036 ExplicitInfo->TypeAsWritten = TyInfo;
2037 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
2038 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
2039 D->ExplicitInfo = ExplicitInfo;
2045 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
2046 ClassTemplatePartialSpecializationDecl *D) {
2047 RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
2049 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
2050 D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
2052 // These are read/set from/to the first declaration.
2053 if (ThisDeclID == Redecl.getFirstID()) {
2054 D->InstantiatedFromMember.setPointer(
2055 ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
2056 D->InstantiatedFromMember.setInt(Record[Idx++]);
2060 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
2061 ClassScopeFunctionSpecializationDecl *D) {
2063 D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
2066 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
2067 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2069 if (ThisDeclID == Redecl.getFirstID()) {
2070 // This FunctionTemplateDecl owns a CommonPtr; read it.
2071 SmallVector<serialization::DeclID, 32> SpecIDs;
2072 ReadDeclIDList(SpecIDs);
2074 if (!SpecIDs.empty()) {
2075 auto *CommonPtr = D->getCommonPtr();
2076 CommonPtr->LazySpecializations = newDeclIDList(
2077 Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
2082 /// TODO: Unify with ClassTemplateSpecializationDecl version?
2083 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
2084 /// VarTemplate(Partial)SpecializationDecl with a new data
2085 /// structure Template(Partial)SpecializationDecl, and
2086 /// using Template(Partial)SpecializationDecl as input type.
2087 ASTDeclReader::RedeclarableResult
2088 ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
2089 VarTemplateSpecializationDecl *D) {
2090 RedeclarableResult Redecl = VisitVarDeclImpl(D);
2092 ASTContext &C = Reader.getContext();
2093 if (Decl *InstD = ReadDecl(Record, Idx)) {
2094 if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
2095 D->SpecializedTemplate = VTD;
2097 SmallVector<TemplateArgument, 8> TemplArgs;
2098 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
2099 TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
2101 VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
2103 VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
2104 PS->PartialSpecialization =
2105 cast<VarTemplatePartialSpecializationDecl>(InstD);
2106 PS->TemplateArgs = ArgList;
2107 D->SpecializedTemplate = PS;
2112 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
2113 VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
2114 new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
2115 ExplicitInfo->TypeAsWritten = TyInfo;
2116 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
2117 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
2118 D->ExplicitInfo = ExplicitInfo;
2121 SmallVector<TemplateArgument, 8> TemplArgs;
2122 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
2123 /*Canonicalize*/ true);
2124 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
2125 D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
2126 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
2128 bool writtenAsCanonicalDecl = Record[Idx++];
2129 if (writtenAsCanonicalDecl) {
2130 VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>(Record, Idx);
2131 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2132 // FIXME: If it's already present, merge it.
2133 if (VarTemplatePartialSpecializationDecl *Partial =
2134 dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
2135 CanonPattern->getCommonPtr()->PartialSpecializations
2136 .GetOrInsertNode(Partial);
2138 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2146 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
2147 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
2148 /// VarTemplate(Partial)SpecializationDecl with a new data
2149 /// structure Template(Partial)SpecializationDecl, and
2150 /// using Template(Partial)SpecializationDecl as input type.
2151 void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
2152 VarTemplatePartialSpecializationDecl *D) {
2153 RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
2155 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
2156 D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
2158 // These are read/set from/to the first declaration.
2159 if (ThisDeclID == Redecl.getFirstID()) {
2160 D->InstantiatedFromMember.setPointer(
2161 ReadDeclAs<VarTemplatePartialSpecializationDecl>(Record, Idx));
2162 D->InstantiatedFromMember.setInt(Record[Idx++]);
2166 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
2169 D->setDeclaredWithTypename(Record[Idx++]);
2172 D->setDefaultArgument(GetTypeSourceInfo(Record, Idx));
2175 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
2176 VisitDeclaratorDecl(D);
2177 // TemplateParmPosition.
2178 D->setDepth(Record[Idx++]);
2179 D->setPosition(Record[Idx++]);
2180 if (D->isExpandedParameterPack()) {
2181 auto TypesAndInfos =
2182 D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
2183 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2184 new (&TypesAndInfos[I].first) QualType(Reader.readType(F, Record, Idx));
2185 TypesAndInfos[I].second = GetTypeSourceInfo(Record, Idx);
2188 // Rest of NonTypeTemplateParmDecl.
2189 D->ParameterPack = Record[Idx++];
2191 D->setDefaultArgument(Reader.ReadExpr(F));
2195 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
2196 VisitTemplateDecl(D);
2197 // TemplateParmPosition.
2198 D->setDepth(Record[Idx++]);
2199 D->setPosition(Record[Idx++]);
2200 if (D->isExpandedParameterPack()) {
2201 TemplateParameterList **Data =
2202 D->getTrailingObjects<TemplateParameterList *>();
2203 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2205 Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
2207 // Rest of TemplateTemplateParmDecl.
2208 D->ParameterPack = Record[Idx++];
2210 D->setDefaultArgument(Reader.getContext(),
2211 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
2215 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2216 VisitRedeclarableTemplateDecl(D);
2219 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
2221 D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
2222 D->AssertExprAndFailed.setInt(Record[Idx++]);
2223 D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
2224 D->RParenLoc = ReadSourceLocation(Record, Idx);
2227 void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
2231 std::pair<uint64_t, uint64_t>
2232 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
2233 uint64_t LexicalOffset = ReadLocalOffset(Record, Idx);
2234 uint64_t VisibleOffset = ReadLocalOffset(Record, Idx);
2235 return std::make_pair(LexicalOffset, VisibleOffset);
2238 template <typename T>
2239 ASTDeclReader::RedeclarableResult
2240 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
2241 DeclID FirstDeclID = ReadDeclID(Record, Idx);
2242 Decl *MergeWith = nullptr;
2244 bool IsKeyDecl = ThisDeclID == FirstDeclID;
2245 bool IsFirstLocalDecl = false;
2247 uint64_t RedeclOffset = 0;
2249 // 0 indicates that this declaration was the only declaration of its entity,
2250 // and is used for space optimization.
2251 if (FirstDeclID == 0) {
2252 FirstDeclID = ThisDeclID;
2254 IsFirstLocalDecl = true;
2255 } else if (unsigned N = Record[Idx++]) {
2256 // This declaration was the first local declaration, but may have imported
2257 // other declarations.
2259 IsFirstLocalDecl = true;
2261 // We have some declarations that must be before us in our redeclaration
2262 // chain. Read them now, and remember that we ought to merge with one of
2264 // FIXME: Provide a known merge target to the second and subsequent such
2266 for (unsigned I = 0; I != N - 1; ++I)
2267 MergeWith = ReadDecl(Record, Idx/*, MergeWith*/);
2269 RedeclOffset = ReadLocalOffset(Record, Idx);
2271 // This declaration was not the first local declaration. Read the first
2272 // local declaration now, to trigger the import of other redeclarations.
2273 (void)ReadDecl(Record, Idx);
2276 T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
2277 if (FirstDecl != D) {
2278 // We delay loading of the redeclaration chain to avoid deeply nested calls.
2279 // We temporarily set the first (canonical) declaration as the previous one
2280 // which is the one that matters and mark the real previous DeclID to be
2281 // loaded & attached later on.
2282 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
2283 D->First = FirstDecl->getCanonicalDecl();
2286 T *DAsT = static_cast<T*>(D);
2288 // Note that we need to load local redeclarations of this decl and build a
2289 // decl chain for them. This must happen *after* we perform the preloading
2290 // above; this ensures that the redeclaration chain is built in the correct
2292 if (IsFirstLocalDecl)
2293 Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));
2295 return RedeclarableResult(FirstDeclID, MergeWith, IsKeyDecl);
2298 /// \brief Attempts to merge the given declaration (D) with another declaration
2299 /// of the same entity.
2300 template<typename T>
2301 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
2302 RedeclarableResult &Redecl,
2303 DeclID TemplatePatternID) {
2304 T *D = static_cast<T*>(DBase);
2306 // If modules are not available, there is no reason to perform this merge.
2307 if (!Reader.getContext().getLangOpts().Modules)
2310 // If we're not the canonical declaration, we don't need to merge.
2311 if (!DBase->isFirstDecl())
2314 if (auto *Existing = Redecl.getKnownMergeTarget())
2315 // We already know of an existing declaration we should merge with.
2316 mergeRedeclarable(D, cast<T>(Existing), Redecl, TemplatePatternID);
2317 else if (FindExistingResult ExistingRes = findExisting(D))
2318 if (T *Existing = ExistingRes)
2319 mergeRedeclarable(D, Existing, Redecl, TemplatePatternID);
2322 /// \brief "Cast" to type T, asserting if we don't have an implicit conversion.
2323 /// We use this to put code in a template that will only be valid for certain
2325 template<typename T> static T assert_cast(T t) { return t; }
2326 template<typename T> static T assert_cast(...) {
2327 llvm_unreachable("bad assert_cast");
2330 /// \brief Merge together the pattern declarations from two template
2332 void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D,
2333 RedeclarableTemplateDecl *Existing,
2334 DeclID DsID, bool IsKeyDecl) {
2335 auto *DPattern = D->getTemplatedDecl();
2336 auto *ExistingPattern = Existing->getTemplatedDecl();
2337 RedeclarableResult Result(DPattern->getCanonicalDecl()->getGlobalID(),
2338 /*MergeWith*/ ExistingPattern, IsKeyDecl);
2340 if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {
2341 // Merge with any existing definition.
2342 // FIXME: This is duplicated in several places. Refactor.
2343 auto *ExistingClass =
2344 cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();
2345 if (auto *DDD = DClass->DefinitionData) {
2346 if (ExistingClass->DefinitionData) {
2347 MergeDefinitionData(ExistingClass, std::move(*DDD));
2349 ExistingClass->DefinitionData = DClass->DefinitionData;
2350 // We may have skipped this before because we thought that DClass
2351 // was the canonical declaration.
2352 Reader.PendingDefinitions.insert(DClass);
2355 DClass->DefinitionData = ExistingClass->DefinitionData;
2357 return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
2360 if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
2361 return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
2363 if (auto *DVar = dyn_cast<VarDecl>(DPattern))
2364 return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
2365 if (auto *DAlias = dyn_cast<TypeAliasDecl>(DPattern))
2366 return mergeRedeclarable(DAlias, cast<TypedefNameDecl>(ExistingPattern),
2368 llvm_unreachable("merged an unknown kind of redeclarable template");
2371 /// \brief Attempts to merge the given declaration (D) with another declaration
2372 /// of the same entity.
2373 template<typename T>
2374 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase, T *Existing,
2375 RedeclarableResult &Redecl,
2376 DeclID TemplatePatternID) {
2377 T *D = static_cast<T*>(DBase);
2378 T *ExistingCanon = Existing->getCanonicalDecl();
2379 T *DCanon = D->getCanonicalDecl();
2380 if (ExistingCanon != DCanon) {
2381 assert(DCanon->getGlobalID() == Redecl.getFirstID() &&
2382 "already merged this declaration");
2384 // Have our redeclaration link point back at the canonical declaration
2385 // of the existing declaration, so that this declaration has the
2386 // appropriate canonical declaration.
2387 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
2388 D->First = ExistingCanon;
2389 ExistingCanon->Used |= D->Used;
2392 // When we merge a namespace, update its pointer to the first namespace.
2393 // We cannot have loaded any redeclarations of this declaration yet, so
2394 // there's nothing else that needs to be updated.
2395 if (auto *Namespace = dyn_cast<NamespaceDecl>(D))
2396 Namespace->AnonOrFirstNamespaceAndInline.setPointer(
2397 assert_cast<NamespaceDecl*>(ExistingCanon));
2399 // When we merge a template, merge its pattern.
2400 if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
2401 mergeTemplatePattern(
2402 DTemplate, assert_cast<RedeclarableTemplateDecl*>(ExistingCanon),
2403 TemplatePatternID, Redecl.isKeyDecl());
2405 // If this declaration is a key declaration, make a note of that.
2406 if (Redecl.isKeyDecl())
2407 Reader.KeyDecls[ExistingCanon].push_back(Redecl.getFirstID());
2411 /// \brief Attempts to merge the given declaration (D) with another declaration
2412 /// of the same entity, for the case where the entity is not actually
2413 /// redeclarable. This happens, for instance, when merging the fields of
2414 /// identical class definitions from two different modules.
2415 template<typename T>
2416 void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
2417 // If modules are not available, there is no reason to perform this merge.
2418 if (!Reader.getContext().getLangOpts().Modules)
2421 // ODR-based merging is only performed in C++. In C, identically-named things
2422 // in different translation units are not redeclarations (but may still have
2423 // compatible types).
2424 if (!Reader.getContext().getLangOpts().CPlusPlus)
2427 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
2428 if (T *Existing = ExistingRes)
2429 Reader.Context.setPrimaryMergedDecl(static_cast<T*>(D),
2430 Existing->getCanonicalDecl());
2433 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2435 unsigned NumVars = D->varlist_size();
2436 SmallVector<Expr *, 16> Vars;
2437 Vars.reserve(NumVars);
2438 for (unsigned i = 0; i != NumVars; ++i) {
2439 Vars.push_back(Reader.ReadExpr(F));
2444 void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
2446 D->setLocation(Reader.ReadSourceLocation(F, Record, Idx));
2447 D->setCombiner(Reader.ReadExpr(F));
2448 D->setInitializer(Reader.ReadExpr(F));
2449 D->PrevDeclInScope = Reader.ReadDeclID(F, Record, Idx);
2452 void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
2456 //===----------------------------------------------------------------------===//
2457 // Attribute Reading
2458 //===----------------------------------------------------------------------===//
2460 /// \brief Reads attributes from the current stream position.
2461 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
2462 const RecordData &Record, unsigned &Idx) {
2463 for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
2464 Attr *New = nullptr;
2465 attr::Kind Kind = (attr::Kind)Record[Idx++];
2466 SourceRange Range = ReadSourceRange(F, Record, Idx);
2468 #include "clang/Serialization/AttrPCHRead.inc"
2470 assert(New && "Unable to decode attribute?");
2471 Attrs.push_back(New);
2475 //===----------------------------------------------------------------------===//
2476 // ASTReader Implementation
2477 //===----------------------------------------------------------------------===//
2479 /// \brief Note that we have loaded the declaration with the given
2482 /// This routine notes that this declaration has already been loaded,
2483 /// so that future GetDecl calls will return this declaration rather
2484 /// than trying to load a new declaration.
2485 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
2486 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
2487 DeclsLoaded[Index] = D;
2491 /// \brief Determine whether the consumer will be interested in seeing
2492 /// this declaration (via HandleTopLevelDecl).
2494 /// This routine should return true for anything that might affect
2495 /// code generation, e.g., inline function definitions, Objective-C
2496 /// declarations with metadata, etc.
2497 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
2498 // An ObjCMethodDecl is never considered as "interesting" because its
2499 // implementation container always is.
2501 if (isa<FileScopeAsmDecl>(D) ||
2502 isa<ObjCProtocolDecl>(D) ||
2503 isa<ObjCImplDecl>(D) ||
2504 isa<ImportDecl>(D) ||
2505 isa<PragmaCommentDecl>(D) ||
2506 isa<PragmaDetectMismatchDecl>(D))
2508 if (isa<OMPThreadPrivateDecl>(D) || isa<OMPDeclareReductionDecl>(D))
2509 return !D->getDeclContext()->isFunctionOrMethod();
2510 if (VarDecl *Var = dyn_cast<VarDecl>(D))
2511 return Var->isFileVarDecl() &&
2512 Var->isThisDeclarationADefinition() == VarDecl::Definition;
2513 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
2514 return Func->doesThisDeclarationHaveABody() || HasBody;
2519 /// \brief Get the correct cursor and offset for loading a declaration.
2520 ASTReader::RecordLocation
2521 ASTReader::DeclCursorForID(DeclID ID, SourceLocation &Loc) {
2522 GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
2523 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
2524 ModuleFile *M = I->second;
2525 const DeclOffset &DOffs =
2526 M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
2527 Loc = TranslateSourceLocation(*M, DOffs.getLocation());
2528 return RecordLocation(M, DOffs.BitOffset);
2531 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
2532 ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
2533 = GlobalBitOffsetsMap.find(GlobalOffset);
2535 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
2536 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
2539 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
2540 return LocalOffset + M.GlobalBitOffset;
2543 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2544 const TemplateParameterList *Y);
2546 /// \brief Determine whether two template parameters are similar enough
2547 /// that they may be used in declarations of the same template.
2548 static bool isSameTemplateParameter(const NamedDecl *X,
2549 const NamedDecl *Y) {
2550 if (X->getKind() != Y->getKind())
2553 if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
2554 const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
2555 return TX->isParameterPack() == TY->isParameterPack();
2558 if (const NonTypeTemplateParmDecl *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
2559 const NonTypeTemplateParmDecl *TY = cast<NonTypeTemplateParmDecl>(Y);
2560 return TX->isParameterPack() == TY->isParameterPack() &&
2561 TX->getASTContext().hasSameType(TX->getType(), TY->getType());
2564 const TemplateTemplateParmDecl *TX = cast<TemplateTemplateParmDecl>(X);
2565 const TemplateTemplateParmDecl *TY = cast<TemplateTemplateParmDecl>(Y);
2566 return TX->isParameterPack() == TY->isParameterPack() &&
2567 isSameTemplateParameterList(TX->getTemplateParameters(),
2568 TY->getTemplateParameters());
2571 static NamespaceDecl *getNamespace(const NestedNameSpecifier *X) {
2572 if (auto *NS = X->getAsNamespace())
2574 if (auto *NAS = X->getAsNamespaceAlias())
2575 return NAS->getNamespace();
2579 static bool isSameQualifier(const NestedNameSpecifier *X,
2580 const NestedNameSpecifier *Y) {
2581 if (auto *NSX = getNamespace(X)) {
2582 auto *NSY = getNamespace(Y);
2583 if (!NSY || NSX->getCanonicalDecl() != NSY->getCanonicalDecl())
2585 } else if (X->getKind() != Y->getKind())
2588 // FIXME: For namespaces and types, we're permitted to check that the entity
2589 // is named via the same tokens. We should probably do so.
2590 switch (X->getKind()) {
2591 case NestedNameSpecifier::Identifier:
2592 if (X->getAsIdentifier() != Y->getAsIdentifier())
2595 case NestedNameSpecifier::Namespace:
2596 case NestedNameSpecifier::NamespaceAlias:
2597 // We've already checked that we named the same namespace.
2599 case NestedNameSpecifier::TypeSpec:
2600 case NestedNameSpecifier::TypeSpecWithTemplate:
2601 if (X->getAsType()->getCanonicalTypeInternal() !=
2602 Y->getAsType()->getCanonicalTypeInternal())
2605 case NestedNameSpecifier::Global:
2606 case NestedNameSpecifier::Super:
2610 // Recurse into earlier portion of NNS, if any.
2611 auto *PX = X->getPrefix();
2612 auto *PY = Y->getPrefix();
2614 return isSameQualifier(PX, PY);
2618 /// \brief Determine whether two template parameter lists are similar enough
2619 /// that they may be used in declarations of the same template.
2620 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2621 const TemplateParameterList *Y) {
2622 if (X->size() != Y->size())
2625 for (unsigned I = 0, N = X->size(); I != N; ++I)
2626 if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
2632 /// \brief Determine whether the two declarations refer to the same entity.
2633 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
2634 assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
2639 // Must be in the same context.
2640 if (!X->getDeclContext()->getRedeclContext()->Equals(
2641 Y->getDeclContext()->getRedeclContext()))
2644 // Two typedefs refer to the same entity if they have the same underlying
2646 if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
2647 if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
2648 return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
2649 TypedefY->getUnderlyingType());
2651 // Must have the same kind.
2652 if (X->getKind() != Y->getKind())
2655 // Objective-C classes and protocols with the same name always match.
2656 if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
2659 if (isa<ClassTemplateSpecializationDecl>(X)) {
2660 // No need to handle these here: we merge them when adding them to the
2665 // Compatible tags match.
2666 if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
2667 TagDecl *TagY = cast<TagDecl>(Y);
2668 return (TagX->getTagKind() == TagY->getTagKind()) ||
2669 ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
2670 TagX->getTagKind() == TTK_Interface) &&
2671 (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
2672 TagY->getTagKind() == TTK_Interface));
2675 // Functions with the same type and linkage match.
2676 // FIXME: This needs to cope with merging of prototyped/non-prototyped
2678 if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
2679 FunctionDecl *FuncY = cast<FunctionDecl>(Y);
2680 if (CXXConstructorDecl *CtorX = dyn_cast<CXXConstructorDecl>(X)) {
2681 CXXConstructorDecl *CtorY = cast<CXXConstructorDecl>(Y);
2682 if (CtorX->getInheritedConstructor() &&
2683 !isSameEntity(CtorX->getInheritedConstructor().getConstructor(),
2684 CtorY->getInheritedConstructor().getConstructor()))
2687 return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
2688 FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
2691 // Variables with the same type and linkage match.
2692 if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
2693 VarDecl *VarY = cast<VarDecl>(Y);
2694 if (VarX->getLinkageInternal() == VarY->getLinkageInternal()) {
2695 ASTContext &C = VarX->getASTContext();
2696 if (C.hasSameType(VarX->getType(), VarY->getType()))
2699 // We can get decls with different types on the redecl chain. Eg.
2700 // template <typename T> struct S { static T Var[]; }; // #1
2701 // template <typename T> T S<T>::Var[sizeof(T)]; // #2
2702 // Only? happens when completing an incomplete array type. In this case
2703 // when comparing #1 and #2 we should go through their element type.
2704 const ArrayType *VarXTy = C.getAsArrayType(VarX->getType());
2705 const ArrayType *VarYTy = C.getAsArrayType(VarY->getType());
2706 if (!VarXTy || !VarYTy)
2708 if (VarXTy->isIncompleteArrayType() || VarYTy->isIncompleteArrayType())
2709 return C.hasSameType(VarXTy->getElementType(), VarYTy->getElementType());
2714 // Namespaces with the same name and inlinedness match.
2715 if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
2716 NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
2717 return NamespaceX->isInline() == NamespaceY->isInline();
2720 // Identical template names and kinds match if their template parameter lists
2721 // and patterns match.
2722 if (TemplateDecl *TemplateX = dyn_cast<TemplateDecl>(X)) {
2723 TemplateDecl *TemplateY = cast<TemplateDecl>(Y);
2724 return isSameEntity(TemplateX->getTemplatedDecl(),
2725 TemplateY->getTemplatedDecl()) &&
2726 isSameTemplateParameterList(TemplateX->getTemplateParameters(),
2727 TemplateY->getTemplateParameters());
2730 // Fields with the same name and the same type match.
2731 if (FieldDecl *FDX = dyn_cast<FieldDecl>(X)) {
2732 FieldDecl *FDY = cast<FieldDecl>(Y);
2733 // FIXME: Also check the bitwidth is odr-equivalent, if any.
2734 return X->getASTContext().hasSameType(FDX->getType(), FDY->getType());
2737 // Indirect fields with the same target field match.
2738 if (auto *IFDX = dyn_cast<IndirectFieldDecl>(X)) {
2739 auto *IFDY = cast<IndirectFieldDecl>(Y);
2740 return IFDX->getAnonField()->getCanonicalDecl() ==
2741 IFDY->getAnonField()->getCanonicalDecl();
2744 // Enumerators with the same name match.
2745 if (isa<EnumConstantDecl>(X))
2746 // FIXME: Also check the value is odr-equivalent.
2749 // Using shadow declarations with the same target match.
2750 if (UsingShadowDecl *USX = dyn_cast<UsingShadowDecl>(X)) {
2751 UsingShadowDecl *USY = cast<UsingShadowDecl>(Y);
2752 return USX->getTargetDecl() == USY->getTargetDecl();
2755 // Using declarations with the same qualifier match. (We already know that
2756 // the name matches.)
2757 if (auto *UX = dyn_cast<UsingDecl>(X)) {
2758 auto *UY = cast<UsingDecl>(Y);
2759 return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
2760 UX->hasTypename() == UY->hasTypename() &&
2761 UX->isAccessDeclaration() == UY->isAccessDeclaration();
2763 if (auto *UX = dyn_cast<UnresolvedUsingValueDecl>(X)) {
2764 auto *UY = cast<UnresolvedUsingValueDecl>(Y);
2765 return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
2766 UX->isAccessDeclaration() == UY->isAccessDeclaration();
2768 if (auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(X))
2769 return isSameQualifier(
2771 cast<UnresolvedUsingTypenameDecl>(Y)->getQualifier());
2773 // Namespace alias definitions with the same target match.
2774 if (auto *NAX = dyn_cast<NamespaceAliasDecl>(X)) {
2775 auto *NAY = cast<NamespaceAliasDecl>(Y);
2776 return NAX->getNamespace()->Equals(NAY->getNamespace());
2782 /// Find the context in which we should search for previous declarations when
2783 /// looking for declarations to merge.
2784 DeclContext *ASTDeclReader::getPrimaryContextForMerging(ASTReader &Reader,
2786 if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
2787 return ND->getOriginalNamespace();
2789 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2790 // Try to dig out the definition.
2791 auto *DD = RD->DefinitionData;
2793 DD = RD->getCanonicalDecl()->DefinitionData;
2795 // If there's no definition yet, then DC's definition is added by an update
2796 // record, but we've not yet loaded that update record. In this case, we
2797 // commit to DC being the canonical definition now, and will fix this when
2798 // we load the update record.
2800 DD = new (Reader.Context) struct CXXRecordDecl::DefinitionData(RD);
2801 RD->IsCompleteDefinition = true;
2802 RD->DefinitionData = DD;
2803 RD->getCanonicalDecl()->DefinitionData = DD;
2805 // Track that we did this horrible thing so that we can fix it later.
2806 Reader.PendingFakeDefinitionData.insert(
2807 std::make_pair(DD, ASTReader::PendingFakeDefinitionKind::Fake));
2810 return DD->Definition;
2813 if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
2814 return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition()
2817 // We can see the TU here only if we have no Sema object. In that case,
2818 // there's no TU scope to look in, so using the DC alone is sufficient.
2819 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2825 ASTDeclReader::FindExistingResult::~FindExistingResult() {
2826 // Record that we had a typedef name for linkage whether or not we merge
2827 // with that declaration.
2828 if (TypedefNameForLinkage) {
2829 DeclContext *DC = New->getDeclContext()->getRedeclContext();
2830 Reader.ImportedTypedefNamesForLinkage.insert(
2831 std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));
2835 if (!AddResult || Existing)
2838 DeclarationName Name = New->getDeclName();
2839 DeclContext *DC = New->getDeclContext()->getRedeclContext();
2840 if (needsAnonymousDeclarationNumber(New)) {
2841 setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
2842 AnonymousDeclNumber, New);
2843 } else if (DC->isTranslationUnit() &&
2844 !Reader.getContext().getLangOpts().CPlusPlus) {
2845 if (Reader.getIdResolver().tryAddTopLevelDecl(New, Name))
2846 Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]
2848 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
2849 // Add the declaration to its redeclaration context so later merging
2850 // lookups will find it.
2851 MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
2855 /// Find the declaration that should be merged into, given the declaration found
2856 /// by name lookup. If we're merging an anonymous declaration within a typedef,
2857 /// we need a matching typedef, and we merge with the type inside it.
2858 static NamedDecl *getDeclForMerging(NamedDecl *Found,
2859 bool IsTypedefNameForLinkage) {
2860 if (!IsTypedefNameForLinkage)
2863 // If we found a typedef declaration that gives a name to some other
2864 // declaration, then we want that inner declaration. Declarations from
2865 // AST files are handled via ImportedTypedefNamesForLinkage.
2866 if (Found->isFromASTFile())
2869 if (auto *TND = dyn_cast<TypedefNameDecl>(Found))
2870 return TND->getAnonDeclWithTypedefName();
2875 NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
2878 // If the lexical context has been merged, look into the now-canonical
2880 if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2883 // If we've seen this before, return the canonical declaration.
2884 auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2885 if (Index < Previous.size() && Previous[Index])
2886 return Previous[Index];
2888 // If this is the first time, but we have parsed a declaration of the context,
2889 // build the anonymous declaration list from the parsed declaration.
2890 if (!cast<Decl>(DC)->isFromASTFile()) {
2891 numberAnonymousDeclsWithin(DC, [&](NamedDecl *ND, unsigned Number) {
2892 if (Previous.size() == Number)
2893 Previous.push_back(cast<NamedDecl>(ND->getCanonicalDecl()));
2895 Previous[Number] = cast<NamedDecl>(ND->getCanonicalDecl());
2899 return Index < Previous.size() ? Previous[Index] : nullptr;
2902 void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
2903 DeclContext *DC, unsigned Index,
2905 if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2908 auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2909 if (Index >= Previous.size())
2910 Previous.resize(Index + 1);
2911 if (!Previous[Index])
2912 Previous[Index] = D;
2915 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
2916 DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
2919 if (!Name && !needsAnonymousDeclarationNumber(D)) {
2920 // Don't bother trying to find unnamed declarations that are in
2921 // unmergeable contexts.
2922 FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
2923 AnonymousDeclNumber, TypedefNameForLinkage);
2928 DeclContext *DC = D->getDeclContext()->getRedeclContext();
2929 if (TypedefNameForLinkage) {
2930 auto It = Reader.ImportedTypedefNamesForLinkage.find(
2931 std::make_pair(DC, TypedefNameForLinkage));
2932 if (It != Reader.ImportedTypedefNamesForLinkage.end())
2933 if (isSameEntity(It->second, D))
2934 return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
2935 TypedefNameForLinkage);
2936 // Go on to check in other places in case an existing typedef name
2937 // was not imported.
2940 if (needsAnonymousDeclarationNumber(D)) {
2941 // This is an anonymous declaration that we may need to merge. Look it up
2942 // in its context by number.
2943 if (auto *Existing = getAnonymousDeclForMerging(
2944 Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
2945 if (isSameEntity(Existing, D))
2946 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2947 TypedefNameForLinkage);
2948 } else if (DC->isTranslationUnit() &&
2949 !Reader.getContext().getLangOpts().CPlusPlus) {
2950 IdentifierResolver &IdResolver = Reader.getIdResolver();
2952 // Temporarily consider the identifier to be up-to-date. We don't want to
2953 // cause additional lookups here.
2954 class UpToDateIdentifierRAII {
2959 explicit UpToDateIdentifierRAII(IdentifierInfo *II)
2960 : II(II), WasOutToDate(false)
2963 WasOutToDate = II->isOutOfDate();
2965 II->setOutOfDate(false);
2969 ~UpToDateIdentifierRAII() {
2971 II->setOutOfDate(true);
2973 } UpToDate(Name.getAsIdentifierInfo());
2975 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2976 IEnd = IdResolver.end();
2978 if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2979 if (isSameEntity(Existing, D))
2980 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2981 TypedefNameForLinkage);
2983 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
2984 DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
2985 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
2986 if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2987 if (isSameEntity(Existing, D))
2988 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2989 TypedefNameForLinkage);
2992 // Not in a mergeable context.
2993 return FindExistingResult(Reader);
2996 // If this declaration is from a merged context, make a note that we need to
2997 // check that the canonical definition of that context contains the decl.
2999 // FIXME: We should do something similar if we merge two definitions of the
3000 // same template specialization into the same CXXRecordDecl.
3001 auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());
3002 if (MergedDCIt != Reader.MergedDeclContexts.end() &&
3003 MergedDCIt->second == D->getDeclContext())
3004 Reader.PendingOdrMergeChecks.push_back(D);
3006 return FindExistingResult(Reader, D, /*Existing=*/nullptr,
3007 AnonymousDeclNumber, TypedefNameForLinkage);
3010 template<typename DeclT>
3011 Decl *ASTDeclReader::getMostRecentDeclImpl(Redeclarable<DeclT> *D) {
3012 return D->RedeclLink.getLatestNotUpdated();
3014 Decl *ASTDeclReader::getMostRecentDeclImpl(...) {
3015 llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");
3018 Decl *ASTDeclReader::getMostRecentDecl(Decl *D) {
3021 switch (D->getKind()) {
3022 #define ABSTRACT_DECL(TYPE)
3023 #define DECL(TYPE, BASE) \
3025 return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
3026 #include "clang/AST/DeclNodes.inc"
3028 llvm_unreachable("unknown decl kind");
3031 Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
3032 return ASTDeclReader::getMostRecentDecl(D->getCanonicalDecl());
3035 template<typename DeclT>
3036 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
3037 Redeclarable<DeclT> *D,
3038 Decl *Previous, Decl *Canon) {
3039 D->RedeclLink.setPrevious(cast<DeclT>(Previous));
3040 D->First = cast<DeclT>(Previous)->First;
3045 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
3046 Redeclarable<FunctionDecl> *D,
3047 Decl *Previous, Decl *Canon) {
3048 FunctionDecl *FD = static_cast<FunctionDecl*>(D);
3049 FunctionDecl *PrevFD = cast<FunctionDecl>(Previous);
3051 FD->RedeclLink.setPrevious(PrevFD);
3052 FD->First = PrevFD->First;
3054 // If the previous declaration is an inline function declaration, then this
3055 // declaration is too.
3056 if (PrevFD->IsInline != FD->IsInline) {
3057 // FIXME: [dcl.fct.spec]p4:
3058 // If a function with external linkage is declared inline in one
3059 // translation unit, it shall be declared inline in all translation
3060 // units in which it appears.
3062 // Be careful of this case:
3065 // template<typename T> struct X { void f(); };
3066 // template<typename T> inline void X<T>::f() {}
3068 // module B instantiates the declaration of X<int>::f
3069 // module C instantiates the definition of X<int>::f
3071 // If module B and C are merged, we do not have a violation of this rule.
3072 FD->IsInline = true;
3075 // If we need to propagate an exception specification along the redecl
3076 // chain, make a note of that so that we can do so later.
3077 auto *FPT = FD->getType()->getAs<FunctionProtoType>();
3078 auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
3079 if (FPT && PrevFPT) {
3080 bool IsUnresolved = isUnresolvedExceptionSpec(FPT->getExceptionSpecType());
3081 bool WasUnresolved =
3082 isUnresolvedExceptionSpec(PrevFPT->getExceptionSpecType());
3083 if (IsUnresolved != WasUnresolved)
3084 Reader.PendingExceptionSpecUpdates.insert(
3085 std::make_pair(Canon, IsUnresolved ? PrevFD : FD));
3088 } // end namespace clang
3090 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) {
3091 llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
3094 /// Inherit the default template argument from \p From to \p To. Returns
3095 /// \c false if there is no default template for \p From.
3096 template <typename ParmDecl>
3097 static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From,
3099 auto *To = cast<ParmDecl>(ToD);
3100 if (!From->hasDefaultArgument())
3102 To->setInheritedDefaultArgument(Context, From);
3106 static void inheritDefaultTemplateArguments(ASTContext &Context,
3109 auto *FromTP = From->getTemplateParameters();
3110 auto *ToTP = To->getTemplateParameters();
3111 assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");
3113 for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {
3114 NamedDecl *FromParam = FromTP->getParam(N - I - 1);
3115 if (FromParam->isParameterPack())
3117 NamedDecl *ToParam = ToTP->getParam(N - I - 1);
3119 if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(FromParam)) {
3120 if (!inheritDefaultTemplateArgument(Context, FTTP, ToParam))
3122 } else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(FromParam)) {
3123 if (!inheritDefaultTemplateArgument(Context, FNTTP, ToParam))
3126 if (!inheritDefaultTemplateArgument(
3127 Context, cast<TemplateTemplateParmDecl>(FromParam), ToParam))
3133 void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,
3134 Decl *Previous, Decl *Canon) {
3135 assert(D && Previous);
3137 switch (D->getKind()) {
3138 #define ABSTRACT_DECL(TYPE)
3139 #define DECL(TYPE, BASE) \
3141 attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
3143 #include "clang/AST/DeclNodes.inc"
3146 // If the declaration was visible in one module, a redeclaration of it in
3147 // another module remains visible even if it wouldn't be visible by itself.
3149 // FIXME: In this case, the declaration should only be visible if a module
3150 // that makes it visible has been imported.
3151 D->IdentifierNamespace |=
3152 Previous->IdentifierNamespace &
3153 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
3155 // If the declaration declares a template, it may inherit default arguments
3156 // from the previous declaration.
3157 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
3158 inheritDefaultTemplateArguments(Reader.getContext(),
3159 cast<TemplateDecl>(Previous), TD);
3162 template<typename DeclT>
3163 void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
3164 D->RedeclLink.setLatest(cast<DeclT>(Latest));
3166 void ASTDeclReader::attachLatestDeclImpl(...) {
3167 llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
3170 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
3171 assert(D && Latest);
3173 switch (D->getKind()) {
3174 #define ABSTRACT_DECL(TYPE)
3175 #define DECL(TYPE, BASE) \
3177 attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
3179 #include "clang/AST/DeclNodes.inc"
3183 template<typename DeclT>
3184 void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
3185 D->RedeclLink.markIncomplete();
3187 void ASTDeclReader::markIncompleteDeclChainImpl(...) {
3188 llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
3191 void ASTReader::markIncompleteDeclChain(Decl *D) {
3192 switch (D->getKind()) {
3193 #define ABSTRACT_DECL(TYPE)
3194 #define DECL(TYPE, BASE) \
3196 ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
3198 #include "clang/AST/DeclNodes.inc"
3202 /// \brief Read the declaration at the given offset from the AST file.
3203 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
3204 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
3205 SourceLocation DeclLoc;
3206 RecordLocation Loc = DeclCursorForID(ID, DeclLoc);
3207 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3208 // Keep track of where we are in the stream, then jump back there
3209 // after reading this declaration.
3210 SavedStreamPosition SavedPosition(DeclsCursor);
3212 ReadingKindTracker ReadingKind(Read_Decl, *this);
3214 // Note that we are loading a declaration record.
3215 Deserializing ADecl(this);
3217 DeclsCursor.JumpToBit(Loc.Offset);
3219 unsigned Code = DeclsCursor.ReadCode();
3221 ASTDeclReader Reader(*this, Loc, ID, DeclLoc, Record,Idx);
3224 switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
3225 case DECL_CONTEXT_LEXICAL:
3226 case DECL_CONTEXT_VISIBLE:
3227 llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
3229 D = TypedefDecl::CreateDeserialized(Context, ID);
3231 case DECL_TYPEALIAS:
3232 D = TypeAliasDecl::CreateDeserialized(Context, ID);
3235 D = EnumDecl::CreateDeserialized(Context, ID);
3238 D = RecordDecl::CreateDeserialized(Context, ID);
3240 case DECL_ENUM_CONSTANT:
3241 D = EnumConstantDecl::CreateDeserialized(Context, ID);
3244 D = FunctionDecl::CreateDeserialized(Context, ID);
3246 case DECL_LINKAGE_SPEC:
3247 D = LinkageSpecDecl::CreateDeserialized(Context, ID);
3250 D = LabelDecl::CreateDeserialized(Context, ID);
3252 case DECL_NAMESPACE:
3253 D = NamespaceDecl::CreateDeserialized(Context, ID);
3255 case DECL_NAMESPACE_ALIAS:
3256 D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
3259 D = UsingDecl::CreateDeserialized(Context, ID);
3261 case DECL_USING_SHADOW:
3262 D = UsingShadowDecl::CreateDeserialized(Context, ID);
3264 case DECL_CONSTRUCTOR_USING_SHADOW:
3265 D = ConstructorUsingShadowDecl::CreateDeserialized(Context, ID);
3267 case DECL_USING_DIRECTIVE:
3268 D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
3270 case DECL_UNRESOLVED_USING_VALUE:
3271 D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
3273 case DECL_UNRESOLVED_USING_TYPENAME:
3274 D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
3276 case DECL_CXX_RECORD:
3277 D = CXXRecordDecl::CreateDeserialized(Context, ID);
3279 case DECL_CXX_METHOD:
3280 D = CXXMethodDecl::CreateDeserialized(Context, ID);
3282 case DECL_CXX_CONSTRUCTOR:
3283 D = CXXConstructorDecl::CreateDeserialized(Context, ID, false);
3285 case DECL_CXX_INHERITED_CONSTRUCTOR:
3286 D = CXXConstructorDecl::CreateDeserialized(Context, ID, true);
3288 case DECL_CXX_DESTRUCTOR:
3289 D = CXXDestructorDecl::CreateDeserialized(Context, ID);
3291 case DECL_CXX_CONVERSION:
3292 D = CXXConversionDecl::CreateDeserialized(Context, ID);
3294 case DECL_ACCESS_SPEC:
3295 D = AccessSpecDecl::CreateDeserialized(Context, ID);
3298 D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3300 case DECL_FRIEND_TEMPLATE:
3301 D = FriendTemplateDecl::CreateDeserialized(Context, ID);
3303 case DECL_CLASS_TEMPLATE:
3304 D = ClassTemplateDecl::CreateDeserialized(Context, ID);
3306 case DECL_CLASS_TEMPLATE_SPECIALIZATION:
3307 D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
3309 case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
3310 D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
3312 case DECL_VAR_TEMPLATE:
3313 D = VarTemplateDecl::CreateDeserialized(Context, ID);
3315 case DECL_VAR_TEMPLATE_SPECIALIZATION:
3316 D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
3318 case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
3319 D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
3321 case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
3322 D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
3324 case DECL_FUNCTION_TEMPLATE:
3325 D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
3327 case DECL_TEMPLATE_TYPE_PARM:
3328 D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
3330 case DECL_NON_TYPE_TEMPLATE_PARM:
3331 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
3333 case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
3334 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3336 case DECL_TEMPLATE_TEMPLATE_PARM:
3337 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
3339 case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
3340 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
3343 case DECL_TYPE_ALIAS_TEMPLATE:
3344 D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
3346 case DECL_STATIC_ASSERT:
3347 D = StaticAssertDecl::CreateDeserialized(Context, ID);
3349 case DECL_OBJC_METHOD:
3350 D = ObjCMethodDecl::CreateDeserialized(Context, ID);
3352 case DECL_OBJC_INTERFACE:
3353 D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
3355 case DECL_OBJC_IVAR:
3356 D = ObjCIvarDecl::CreateDeserialized(Context, ID);
3358 case DECL_OBJC_PROTOCOL:
3359 D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
3361 case DECL_OBJC_AT_DEFS_FIELD:
3362 D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
3364 case DECL_OBJC_CATEGORY:
3365 D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
3367 case DECL_OBJC_CATEGORY_IMPL:
3368 D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
3370 case DECL_OBJC_IMPLEMENTATION:
3371 D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
3373 case DECL_OBJC_COMPATIBLE_ALIAS:
3374 D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
3376 case DECL_OBJC_PROPERTY:
3377 D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
3379 case DECL_OBJC_PROPERTY_IMPL:
3380 D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
3383 D = FieldDecl::CreateDeserialized(Context, ID);
3385 case DECL_INDIRECTFIELD:
3386 D = IndirectFieldDecl::CreateDeserialized(Context, ID);
3389 D = VarDecl::CreateDeserialized(Context, ID);
3391 case DECL_IMPLICIT_PARAM:
3392 D = ImplicitParamDecl::CreateDeserialized(Context, ID);
3395 D = ParmVarDecl::CreateDeserialized(Context, ID);
3397 case DECL_FILE_SCOPE_ASM:
3398 D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
3401 D = BlockDecl::CreateDeserialized(Context, ID);
3403 case DECL_MS_PROPERTY:
3404 D = MSPropertyDecl::CreateDeserialized(Context, ID);
3407 D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3409 case DECL_CXX_BASE_SPECIFIERS:
3410 Error("attempt to read a C++ base-specifier record as a declaration");
3412 case DECL_CXX_CTOR_INITIALIZERS:
3413 Error("attempt to read a C++ ctor initializer record as a declaration");
3416 // Note: last entry of the ImportDecl record is the number of stored source
3418 D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
3420 case DECL_OMP_THREADPRIVATE:
3421 D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3423 case DECL_OMP_DECLARE_REDUCTION:
3424 D = OMPDeclareReductionDecl::CreateDeserialized(Context, ID);
3426 case DECL_OMP_CAPTUREDEXPR:
3427 D = OMPCapturedExprDecl::CreateDeserialized(Context, ID);
3429 case DECL_PRAGMA_COMMENT:
3430 D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3432 case DECL_PRAGMA_DETECT_MISMATCH:
3433 D = PragmaDetectMismatchDecl::CreateDeserialized(Context, ID,
3437 D = EmptyDecl::CreateDeserialized(Context, ID);
3439 case DECL_OBJC_TYPE_PARAM:
3440 D = ObjCTypeParamDecl::CreateDeserialized(Context, ID);
3444 assert(D && "Unknown declaration reading AST file");
3445 LoadedDecl(Index, D);
3446 // Set the DeclContext before doing any deserialization, to make sure internal
3447 // calls to Decl::getASTContext() by Decl's methods will find the
3448 // TranslationUnitDecl without crashing.
3449 D->setDeclContext(Context.getTranslationUnitDecl());
3452 // If this declaration is also a declaration context, get the
3453 // offsets for its tables of lexical and visible declarations.
3454 if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
3455 std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
3456 if (Offsets.first &&
3457 ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, Offsets.first, DC))
3459 if (Offsets.second &&
3460 ReadVisibleDeclContextStorage(*Loc.F, DeclsCursor, Offsets.second, ID))
3463 assert(Idx == Record.size());
3465 // Load any relevant update records.
3466 PendingUpdateRecords.push_back(std::make_pair(ID, D));
3468 // Load the categories after recursive loading is finished.
3469 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
3470 if (Class->isThisDeclarationADefinition())
3471 loadObjCCategories(ID, Class);
3473 // If we have deserialized a declaration that has a definition the
3474 // AST consumer might need to know about, queue it.
3475 // We don't pass it to the consumer immediately because we may be in recursive
3476 // loading, and some declarations may still be initializing.
3477 if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
3478 InterestingDecls.push_back(D);
3483 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
3484 // The declaration may have been modified by files later in the chain.
3485 // If this is the case, read the record containing the updates from each file
3486 // and pass it to ASTDeclReader to make the modifications.
3487 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
3488 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
3489 if (UpdI != DeclUpdateOffsets.end()) {
3490 auto UpdateOffsets = std::move(UpdI->second);
3491 DeclUpdateOffsets.erase(UpdI);
3493 bool WasInteresting = isConsumerInterestedIn(D, false);
3494 for (auto &FileAndOffset : UpdateOffsets) {
3495 ModuleFile *F = FileAndOffset.first;
3496 uint64_t Offset = FileAndOffset.second;
3497 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3498 SavedStreamPosition SavedPosition(Cursor);
3499 Cursor.JumpToBit(Offset);
3501 unsigned Code = Cursor.ReadCode();
3502 unsigned RecCode = Cursor.readRecord(Code, Record);
3504 assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
3507 ASTDeclReader Reader(*this, RecordLocation(F, Offset), ID,
3508 SourceLocation(), Record, Idx);
3509 Reader.UpdateDecl(D, *F, Record);
3511 // We might have made this declaration interesting. If so, remember that
3512 // we need to hand it off to the consumer.
3513 if (!WasInteresting &&
3514 isConsumerInterestedIn(D, Reader.hasPendingBody())) {
3515 InterestingDecls.push_back(D);
3516 WasInteresting = true;
3521 // Load the pending visible updates for this decl context, if it has any.
3522 auto I = PendingVisibleUpdates.find(ID);
3523 if (I != PendingVisibleUpdates.end()) {
3524 auto VisibleUpdates = std::move(I->second);
3525 PendingVisibleUpdates.erase(I);
3527 auto *DC = cast<DeclContext>(D)->getPrimaryContext();
3528 for (const PendingVisibleUpdate &Update : VisibleUpdates)
3529 Lookups[DC].Table.add(
3530 Update.Mod, Update.Data,
3531 reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));
3532 DC->setHasExternalVisibleStorage(true);
3536 void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {
3537 // Attach FirstLocal to the end of the decl chain.
3538 Decl *CanonDecl = FirstLocal->getCanonicalDecl();
3539 if (FirstLocal != CanonDecl) {
3540 Decl *PrevMostRecent = ASTDeclReader::getMostRecentDecl(CanonDecl);
3541 ASTDeclReader::attachPreviousDecl(
3542 *this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,
3547 ASTDeclReader::attachLatestDecl(CanonDecl, FirstLocal);
3551 // Load the list of other redeclarations from this module file.
3552 ModuleFile *M = getOwningModuleFile(FirstLocal);
3553 assert(M && "imported decl from no module file");
3555 llvm::BitstreamCursor &Cursor = M->DeclsCursor;
3556 SavedStreamPosition SavedPosition(Cursor);
3557 Cursor.JumpToBit(LocalOffset);
3560 unsigned Code = Cursor.ReadCode();
3561 unsigned RecCode = Cursor.readRecord(Code, Record);
3563 assert(RecCode == LOCAL_REDECLARATIONS && "expected LOCAL_REDECLARATIONS record!");
3565 // FIXME: We have several different dispatches on decl kind here; maybe
3566 // we should instead generate one loop per kind and dispatch up-front?
3567 Decl *MostRecent = FirstLocal;
3568 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3569 auto *D = GetLocalDecl(*M, Record[N - I - 1]);
3570 ASTDeclReader::attachPreviousDecl(*this, D, MostRecent, CanonDecl);
3573 ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
3577 /// \brief Given an ObjC interface, goes through the modules and links to the
3578 /// interface all the categories for it.
3579 class ObjCCategoriesVisitor {
3581 serialization::GlobalDeclID InterfaceID;
3582 ObjCInterfaceDecl *Interface;
3583 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
3584 unsigned PreviousGeneration;
3585 ObjCCategoryDecl *Tail;
3586 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
3588 void add(ObjCCategoryDecl *Cat) {
3589 // Only process each category once.
3590 if (!Deserialized.erase(Cat))
3593 // Check for duplicate categories.
3594 if (Cat->getDeclName()) {
3595 ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
3597 Reader.getOwningModuleFile(Existing)
3598 != Reader.getOwningModuleFile(Cat)) {
3599 // FIXME: We should not warn for duplicates in diamond:
3607 // If there are duplicates in ML/MR, there will be warning when
3608 // creating MB *and* when importing MB. We should not warn when
3610 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
3611 << Interface->getDeclName() << Cat->getDeclName();
3612 Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
3613 } else if (!Existing) {
3614 // Record this category.
3619 // Add this category to the end of the chain.
3621 ASTDeclReader::setNextObjCCategory(Tail, Cat);
3623 Interface->setCategoryListRaw(Cat);
3628 ObjCCategoriesVisitor(ASTReader &Reader,
3629 serialization::GlobalDeclID InterfaceID,
3630 ObjCInterfaceDecl *Interface,
3631 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
3632 unsigned PreviousGeneration)
3633 : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
3634 Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
3637 // Populate the name -> category map with the set of known categories.
3638 for (auto *Cat : Interface->known_categories()) {
3639 if (Cat->getDeclName())
3640 NameCategoryMap[Cat->getDeclName()] = Cat;
3642 // Keep track of the tail of the category list.
3647 bool operator()(ModuleFile &M) {
3648 // If we've loaded all of the category information we care about from
3649 // this module file, we're done.
3650 if (M.Generation <= PreviousGeneration)
3653 // Map global ID of the definition down to the local ID used in this
3654 // module file. If there is no such mapping, we'll find nothing here
3655 // (or in any module it imports).
3656 DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
3660 // Perform a binary search to find the local redeclarations for this
3661 // declaration (if any).
3662 const ObjCCategoriesInfo Compare = { LocalID, 0 };
3663 const ObjCCategoriesInfo *Result
3664 = std::lower_bound(M.ObjCCategoriesMap,
3665 M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
3667 if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
3668 Result->DefinitionID != LocalID) {
3669 // We didn't find anything. If the class definition is in this module
3670 // file, then the module files it depends on cannot have any categories,
3671 // so suppress further lookup.
3672 return Reader.isDeclIDFromModule(InterfaceID, M);
3675 // We found something. Dig out all of the categories.
3676 unsigned Offset = Result->Offset;
3677 unsigned N = M.ObjCCategories[Offset];
3678 M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
3679 for (unsigned I = 0; I != N; ++I)
3680 add(cast_or_null<ObjCCategoryDecl>(
3681 Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
3685 } // end anonymous namespace
3687 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
3688 ObjCInterfaceDecl *D,
3689 unsigned PreviousGeneration) {
3690 ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
3691 PreviousGeneration);
3692 ModuleMgr.visit(Visitor);
3695 template<typename DeclT, typename Fn>
3696 static void forAllLaterRedecls(DeclT *D, Fn F) {
3699 // Check whether we've already merged D into its redeclaration chain.
3700 // MostRecent may or may not be nullptr if D has not been merged. If
3701 // not, walk the merged redecl chain and see if it's there.
3702 auto *MostRecent = D->getMostRecentDecl();
3704 for (auto *Redecl = MostRecent; Redecl && !Found;
3705 Redecl = Redecl->getPreviousDecl())
3706 Found = (Redecl == D);
3708 // If this declaration is merged, apply the functor to all later decls.
3710 for (auto *Redecl = MostRecent; Redecl != D;
3711 Redecl = Redecl->getPreviousDecl())
3716 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
3717 const RecordData &Record) {
3718 while (Idx < Record.size()) {
3719 switch ((DeclUpdateKind)Record[Idx++]) {
3720 case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
3721 auto *RD = cast<CXXRecordDecl>(D);
3722 // FIXME: If we also have an update record for instantiating the
3723 // definition of D, we need that to happen before we get here.
3724 Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
3725 assert(MD && "couldn't read decl from update record");
3726 // FIXME: We should call addHiddenDecl instead, to add the member
3727 // to its DeclContext.
3728 RD->addedMember(MD);
3732 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
3733 // It will be added to the template's specializations set when loaded.
3734 (void)Reader.ReadDecl(ModuleFile, Record, Idx);
3737 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
3739 = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
3741 // Each module has its own anonymous namespace, which is disjoint from
3742 // any other module's anonymous namespaces, so don't attach the anonymous
3743 // namespace at all.
3744 if (ModuleFile.Kind != MK_ImplicitModule &&
3745 ModuleFile.Kind != MK_ExplicitModule) {
3746 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
3747 TU->setAnonymousNamespace(Anon);
3749 cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
3754 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
3755 cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
3756 Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3759 case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: {
3760 auto Param = cast<ParmVarDecl>(D);
3762 // We have to read the default argument regardless of whether we use it
3763 // so that hypothetical further update records aren't messed up.
3764 // TODO: Add a function to skip over the next expr record.
3765 auto DefaultArg = Reader.ReadExpr(F);
3767 // Only apply the update if the parameter still has an uninstantiated
3768 // default argument.
3769 if (Param->hasUninstantiatedDefaultArg())
3770 Param->setDefaultArg(DefaultArg);
3774 case UPD_CXX_ADDED_FUNCTION_DEFINITION: {
3775 FunctionDecl *FD = cast<FunctionDecl>(D);
3776 if (Reader.PendingBodies[FD]) {
3777 // FIXME: Maybe check for ODR violations.
3778 // It's safe to stop now because this update record is always last.
3782 if (Record[Idx++]) {
3783 // Maintain AST consistency: any later redeclarations of this function
3784 // are inline if this one is. (We might have merged another declaration
3786 forAllLaterRedecls(FD, [](FunctionDecl *FD) {
3787 FD->setImplicitlyInline();
3790 FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3791 if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
3792 CD->NumCtorInitializers = Record[Idx++];
3793 if (CD->NumCtorInitializers)
3794 CD->CtorInitializers = ReadGlobalOffset(F, Record, Idx);
3796 // Store the offset of the body so we can lazily load it later.
3797 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
3798 HasPendingBody = true;
3799 assert(Idx == Record.size() && "lazy body must be last");
3803 case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
3804 auto *RD = cast<CXXRecordDecl>(D);
3805 auto *OldDD = RD->getCanonicalDecl()->DefinitionData;
3806 bool HadRealDefinition =
3807 OldDD && (OldDD->Definition != RD ||
3808 !Reader.PendingFakeDefinitionData.count(OldDD));
3809 ReadCXXRecordDefinition(RD, /*Update*/true);
3811 // Visible update is handled separately.
3812 uint64_t LexicalOffset = ReadLocalOffset(Record, Idx);
3813 if (!HadRealDefinition && LexicalOffset) {
3814 Reader.ReadLexicalDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
3816 Reader.PendingFakeDefinitionData.erase(OldDD);
3819 auto TSK = (TemplateSpecializationKind)Record[Idx++];
3820 SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
3821 if (MemberSpecializationInfo *MSInfo =
3822 RD->getMemberSpecializationInfo()) {
3823 MSInfo->setTemplateSpecializationKind(TSK);
3824 MSInfo->setPointOfInstantiation(POI);
3826 ClassTemplateSpecializationDecl *Spec =
3827 cast<ClassTemplateSpecializationDecl>(RD);
3828 Spec->setTemplateSpecializationKind(TSK);
3829 Spec->setPointOfInstantiation(POI);
3831 if (Record[Idx++]) {
3833 ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx);
3834 SmallVector<TemplateArgument, 8> TemplArgs;
3835 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
3836 auto *TemplArgList = TemplateArgumentList::CreateCopy(
3837 Reader.getContext(), TemplArgs);
3839 // FIXME: If we already have a partial specialization set,
3840 // check that it matches.
3841 if (!Spec->getSpecializedTemplateOrPartial()
3842 .is<ClassTemplatePartialSpecializationDecl *>())
3843 Spec->setInstantiationOf(PartialSpec, TemplArgList);
3847 RD->setTagKind((TagTypeKind)Record[Idx++]);
3848 RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3849 RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3850 RD->setBraceRange(Reader.ReadSourceRange(ModuleFile, Record, Idx));
3852 if (Record[Idx++]) {
3854 Reader.ReadAttributes(F, Attrs, Record, Idx);
3855 D->setAttrsImpl(Attrs, Reader.getContext());
3860 case UPD_CXX_RESOLVED_DTOR_DELETE: {
3861 // Set the 'operator delete' directly to avoid emitting another update
3863 auto *Del = Reader.ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
3864 auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());
3865 // FIXME: Check consistency if we have an old and new operator delete.
3866 if (!First->OperatorDelete)
3867 First->OperatorDelete = Del;
3871 case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
3872 FunctionProtoType::ExceptionSpecInfo ESI;
3873 SmallVector<QualType, 8> ExceptionStorage;
3874 Reader.readExceptionSpec(ModuleFile, ExceptionStorage, ESI, Record, Idx);
3876 // Update this declaration's exception specification, if needed.
3877 auto *FD = cast<FunctionDecl>(D);
3878 auto *FPT = FD->getType()->castAs<FunctionProtoType>();
3879 // FIXME: If the exception specification is already present, check that it
3881 if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
3882 FD->setType(Reader.Context.getFunctionType(
3883 FPT->getReturnType(), FPT->getParamTypes(),
3884 FPT->getExtProtoInfo().withExceptionSpec(ESI)));
3886 // When we get to the end of deserializing, see if there are other decls
3887 // that we need to propagate this exception specification onto.
3888 Reader.PendingExceptionSpecUpdates.insert(
3889 std::make_pair(FD->getCanonicalDecl(), FD));
3894 case UPD_CXX_DEDUCED_RETURN_TYPE: {
3895 // FIXME: Also do this when merging redecls.
3896 QualType DeducedResultType = Reader.readType(ModuleFile, Record, Idx);
3897 for (auto *Redecl : merged_redecls(D)) {
3898 // FIXME: If the return type is already deduced, check that it matches.
3899 FunctionDecl *FD = cast<FunctionDecl>(Redecl);
3900 Reader.Context.adjustDeducedFunctionResultType(FD, DeducedResultType);
3905 case UPD_DECL_MARKED_USED: {
3906 // Maintain AST consistency: any later redeclarations are used too.
3907 D->markUsed(Reader.Context);
3911 case UPD_MANGLING_NUMBER:
3912 Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
3915 case UPD_STATIC_LOCAL_NUMBER:
3916 Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
3919 case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
3920 D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
3921 Reader.Context, ReadSourceRange(Record, Idx)));
3924 case UPD_DECL_EXPORTED: {
3925 unsigned SubmoduleID = readSubmoduleID(Record, Idx);
3926 auto *Exported = cast<NamedDecl>(D);
3927 if (auto *TD = dyn_cast<TagDecl>(Exported))
3928 Exported = TD->getDefinition();
3929 Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
3930 if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
3931 Reader.getContext().mergeDefinitionIntoModule(cast<NamedDecl>(Exported),
3933 Reader.PendingMergedDefinitionsToDeduplicate.insert(
3934 cast<NamedDecl>(Exported));
3935 } else if (Owner && Owner->NameVisibility != Module::AllVisible) {
3936 // If Owner is made visible at some later point, make this declaration
3938 Reader.HiddenNamesMap[Owner].push_back(Exported);
3940 // The declaration is now visible.
3941 Exported->Hidden = false;
3946 case UPD_DECL_MARKED_OPENMP_DECLARETARGET:
3947 case UPD_ADDED_ATTR_TO_RECORD:
3949 Reader.ReadAttributes(F, Attrs, Record, Idx);
3950 assert(Attrs.size() == 1);
3951 D->addAttr(Attrs[0]);