1 //===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the ASTReader::ReadDeclRecord method, which is the
11 // entrypoint for loading a decl.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "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"
28 
29 using namespace clang;
30 using namespace clang::serialization;
31 
32 //===----------------------------------------------------------------------===//
33 // Declaration deserialization
34 //===----------------------------------------------------------------------===//
35 
36 namespace clang {
37   class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
38     ASTReader &Reader;
39     ModuleFile &F;
40     uint64_t Offset;
41     const DeclID ThisDeclID;
42     const SourceLocation ThisDeclLoc;
43     typedef ASTReader::RecordData RecordData;
44     const RecordData &Record;
45     unsigned &Idx;
46     TypeID TypeIDForTypeDecl;
47     unsigned AnonymousDeclNumber;
48     GlobalDeclID NamedDeclForTagDecl;
49     IdentifierInfo *TypedefNameForLinkage;
50 
51     bool HasPendingBody;
52 
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;
57 
58     uint64_t GetCurrentCursorOffset();
59 
ReadLocalOffset(const RecordData & R,unsigned & I)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;
64     }
65 
ReadGlobalOffset(ModuleFile & F,const RecordData & R,unsigned & I)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;
69     }
70 
ReadSourceLocation(const RecordData & R,unsigned & I)71     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
72       return Reader.ReadSourceLocation(F, R, I);
73     }
74 
ReadSourceRange(const RecordData & R,unsigned & I)75     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
76       return Reader.ReadSourceRange(F, R, I);
77     }
78 
GetTypeSourceInfo(const RecordData & R,unsigned & I)79     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
80       return Reader.GetTypeSourceInfo(F, R, I);
81     }
82 
ReadDeclID(const RecordData & R,unsigned & I)83     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
84       return Reader.ReadDeclID(F, R, I);
85     }
86 
ReadString(const RecordData & R,unsigned & I)87     std::string ReadString(const RecordData &R, unsigned &I) {
88       return Reader.ReadString(R, I);
89     }
90 
ReadDeclIDList(SmallVectorImpl<DeclID> & IDs)91     void ReadDeclIDList(SmallVectorImpl<DeclID> &IDs) {
92       for (unsigned I = 0, Size = Record[Idx++]; I != Size; ++I)
93         IDs.push_back(ReadDeclID(Record, Idx));
94     }
95 
ReadDecl(const RecordData & R,unsigned & I)96     Decl *ReadDecl(const RecordData &R, unsigned &I) {
97       return Reader.ReadDecl(F, R, I);
98     }
99 
100     template<typename T>
ReadDeclAs(const RecordData & R,unsigned & I)101     T *ReadDeclAs(const RecordData &R, unsigned &I) {
102       return Reader.ReadDeclAs<T>(F, R, I);
103     }
104 
ReadQualifierInfo(QualifierInfo & Info,const RecordData & R,unsigned & I)105     void ReadQualifierInfo(QualifierInfo &Info,
106                            const RecordData &R, unsigned &I) {
107       Reader.ReadQualifierInfo(F, Info, R, I);
108     }
109 
ReadDeclarationNameLoc(DeclarationNameLoc & DNLoc,DeclarationName Name,const RecordData & R,unsigned & I)110     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
111                                 const RecordData &R, unsigned &I) {
112       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
113     }
114 
ReadDeclarationNameInfo(DeclarationNameInfo & NameInfo,const RecordData & R,unsigned & I)115     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
116                                 const RecordData &R, unsigned &I) {
117       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
118     }
119 
readSubmoduleID(const RecordData & R,unsigned & I)120     serialization::SubmoduleID readSubmoduleID(const RecordData &R,
121                                                unsigned &I) {
122       if (I >= R.size())
123         return 0;
124 
125       return Reader.getGlobalSubmoduleID(F, R[I++]);
126     }
127 
readModule(const RecordData & R,unsigned & I)128     Module *readModule(const RecordData &R, unsigned &I) {
129       return Reader.getSubmodule(readSubmoduleID(R, I));
130     }
131 
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);
137 
138     static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
139                                                  DeclContext *DC,
140                                                  unsigned Index);
141     static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
142                                            unsigned Index, NamedDecl *D);
143 
144     /// Results from loading a RedeclarableDecl.
145     class RedeclarableResult {
146       GlobalDeclID FirstID;
147       Decl *MergeWith;
148       bool IsKeyDecl;
149 
150     public:
RedeclarableResult(GlobalDeclID FirstID,Decl * MergeWith,bool IsKeyDecl)151       RedeclarableResult(GlobalDeclID FirstID, Decl *MergeWith, bool IsKeyDecl)
152           : FirstID(FirstID), MergeWith(MergeWith), IsKeyDecl(IsKeyDecl) {}
153 
154       /// \brief Retrieve the first ID.
getFirstID() const155       GlobalDeclID getFirstID() const { return FirstID; }
156 
157       /// \brief Is this declaration a key declaration?
isKeyDecl() const158       bool isKeyDecl() const { return IsKeyDecl; }
159 
160       /// \brief Get a known declaration that this should be merged with, if
161       /// any.
getKnownMergeTarget() const162       Decl *getKnownMergeTarget() const { return MergeWith; }
163     };
164 
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)
169     /// if requested.
170     class FindExistingResult {
171       ASTReader &Reader;
172       NamedDecl *New;
173       NamedDecl *Existing;
174       mutable bool AddResult;
175 
176       unsigned AnonymousDeclNumber;
177       IdentifierInfo *TypedefNameForLinkage;
178 
179       void operator=(FindExistingResult&) = delete;
180 
181     public:
FindExistingResult(ASTReader & Reader)182       FindExistingResult(ASTReader &Reader)
183           : Reader(Reader), New(nullptr), Existing(nullptr), AddResult(false),
184             AnonymousDeclNumber(0), TypedefNameForLinkage(nullptr) {}
185 
FindExistingResult(ASTReader & Reader,NamedDecl * New,NamedDecl * Existing,unsigned AnonymousDeclNumber,IdentifierInfo * TypedefNameForLinkage)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) {}
192 
FindExistingResult(const FindExistingResult & Other)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;
199       }
200 
201       ~FindExistingResult();
202 
203       /// \brief Suppress the addition of this result into the known set of
204       /// names.
suppress()205       void suppress() { AddResult = false; }
206 
operator NamedDecl*() const207       operator NamedDecl*() const { return Existing; }
208 
209       template<typename T>
operator T*() const210       operator T*() const { return dyn_cast_or_null<T>(Existing); }
211     };
212 
213     static DeclContext *getPrimaryContextForMerging(ASTReader &Reader,
214                                                     DeclContext *DC);
215     FindExistingResult findExisting(NamedDecl *D);
216 
217   public:
ASTDeclReader(ASTReader & Reader,ASTReader::RecordLocation Loc,DeclID thisDeclID,SourceLocation ThisDeclLoc,const RecordData & Record,unsigned & Idx)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) {}
226 
227     template <typename DeclT>
228     static Decl *getMostRecentDeclImpl(Redeclarable<DeclT> *D);
229     static Decl *getMostRecentDeclImpl(...);
230     static Decl *getMostRecentDecl(Decl *D);
231 
232     template <typename DeclT>
233     static void attachPreviousDeclImpl(ASTReader &Reader,
234                                        Redeclarable<DeclT> *D, Decl *Previous,
235                                        Decl *Canon);
236     static void attachPreviousDeclImpl(ASTReader &Reader, ...);
237     static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,
238                                    Decl *Canon);
239 
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);
244 
245     template <typename DeclT>
246     static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
247     static void markIncompleteDeclChainImpl(...);
248 
249     /// \brief Determine whether this declaration has a pending body.
hasPendingBody() const250     bool hasPendingBody() const { return HasPendingBody; }
251 
252     void Visit(Decl *D);
253 
254     void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
255                     const RecordData &Record);
256 
setNextObjCCategory(ObjCCategoryDecl * Cat,ObjCCategoryDecl * Next)257     static void setNextObjCCategory(ObjCCategoryDecl *Cat,
258                                     ObjCCategoryDecl *Next) {
259       Cat->NextClassCategory = Next;
260     }
261 
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);
VisitRecordDecl(RecordDecl * RD)279     void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
280     RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
VisitCXXRecordDecl(CXXRecordDecl * D)281     void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
282     RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
283                                             ClassTemplateSpecializationDecl *D);
VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl * D)284     void VisitClassTemplateSpecializationDecl(
285         ClassTemplateSpecializationDecl *D) {
286       VisitClassTemplateSpecializationDeclImpl(D);
287     }
288     void VisitClassTemplatePartialSpecializationDecl(
289                                      ClassTemplatePartialSpecializationDecl *D);
290     void VisitClassScopeFunctionSpecializationDecl(
291                                        ClassScopeFunctionSpecializationDecl *D);
292     RedeclarableResult
293     VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl * D)294     void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
295       VisitVarTemplateSpecializationDeclImpl(D);
296     }
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);
VisitVarDecl(VarDecl * VD)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);
338 
339     std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
340 
341     template<typename T>
342     RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
343 
344     template<typename T>
345     void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
346                            DeclID TemplatePatternID = 0);
347 
348     template<typename T>
349     void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
350                            RedeclarableResult &Redecl,
351                            DeclID TemplatePatternID = 0);
352 
353     template<typename T>
354     void mergeMergeable(Mergeable<T> *D);
355 
356     void mergeTemplatePattern(RedeclarableTemplateDecl *D,
357                               RedeclarableTemplateDecl *Existing,
358                               DeclID DsID, bool IsKeyDecl);
359 
360     ObjCTypeParamList *ReadObjCTypeParamList();
361 
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);
380 
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
383     /// visible.
mergeDefinitionVisibility(NamedDecl * Def,NamedDecl * MergedDef)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())
388           Def->Hidden = false;
389         else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
390           Reader.getContext().mergeDefinitionIntoModule(
391               Def, MergedDef->getImportedOwningModule(),
392               /*NotifyListeners*/ false);
393           Reader.PendingMergedDefinitionsToDeduplicate.insert(Def);
394         } else {
395           auto SubmoduleID = MergedDef->getOwningModuleID();
396           assert(SubmoduleID && "hidden definition in no module");
397           Reader.HiddenNamesMap[Reader.getSubmodule(SubmoduleID)].push_back(Def);
398         }
399       }
400     }
401   };
402 } // end namespace clang
403 
404 namespace {
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;
410 public:
MergedRedeclIterator()411   MergedRedeclIterator() : Current(nullptr) {}
MergedRedeclIterator(DeclT * Start)412   MergedRedeclIterator(DeclT *Start)
413       : Start(Start), Canonical(nullptr), Current(Start) {}
414 
operator *()415   DeclT *operator*() { return Current; }
416 
operator ++()417   MergedRedeclIterator &operator++() {
418     if (Current->isFirstDecl()) {
419       Canonical = Current;
420       Current = Current->getMostRecentDecl();
421     } else
422       Current = Current->getPreviousDecl();
423 
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
427     // again.
428     if (Current == Start || Current == Canonical)
429       Current = nullptr;
430     return *this;
431   }
432 
operator !=(const MergedRedeclIterator & A,const MergedRedeclIterator & B)433   friend bool operator!=(const MergedRedeclIterator &A,
434                          const MergedRedeclIterator &B) {
435     return A.Current != B.Current;
436   }
437 };
438 } // end anonymous namespace
439 
440 template<typename DeclT>
merged_redecls(DeclT * D)441 llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) {
442   return llvm::make_range(MergedRedeclIterator<DeclT>(D),
443                           MergedRedeclIterator<DeclT>());
444 }
445 
GetCurrentCursorOffset()446 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
447   return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
448 }
449 
Visit(Decl * D)450 void ASTDeclReader::Visit(Decl *D) {
451   DeclVisitor<ASTDeclReader, void>::Visit(D);
452 
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;
457 
458   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
459     if (DD->DeclInfo) {
460       DeclaratorDecl::ExtInfo *Info =
461           DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
462       Info->TInfo =
463           GetTypeSourceInfo(Record, Idx);
464     }
465     else {
466       DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
467     }
468   }
469 
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());
473 
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
485     // module).
486     // FIXME: Can we diagnose ODR violations somehow?
487     if (Record[Idx++]) {
488       if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
489         CD->NumCtorInitializers = Record[Idx++];
490         if (CD->NumCtorInitializers)
491           CD->CtorInitializers = ReadGlobalOffset(F, Record, Idx);
492       }
493       Reader.PendingBodies[FD] = GetCurrentCursorOffset();
494       HasPendingBody = true;
495     }
496   }
497 }
498 
VisitDecl(Decl * D)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
507     // placeholder.
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());
516   } else {
517     DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
518     DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
519     if (!LexicalDC)
520       LexicalDC = SemaDC;
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());
526   }
527   D->setLocation(ThisDeclLoc);
528   D->setInvalidDecl(Record[Idx++]);
529   if (Record[Idx++]) { // hasAttrs
530     AttrVec Attrs;
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());
535   }
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();
545 
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);
551 
552     if (D->Hidden) {
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.
558       D->Hidden = true;
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.
562         D->Hidden = true;
563 
564         // Note that this declaration was hidden because its owning module is
565         // not yet visible.
566         Reader.HiddenNamesMap[Owner].push_back(D);
567       }
568     }
569   }
570 }
571 
VisitPragmaCommentDecl(PragmaCommentDecl * D)572 void ASTDeclReader::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
573   VisitDecl(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';
579 }
580 
VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl * D)581 void ASTDeclReader::VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) {
582   VisitDecl(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';
587 
588   D->ValueStart = Name.size() + 1;
589   std::string Value = ReadString(Record, Idx);
590   memcpy(D->getTrailingObjects<char>() + D->ValueStart, Value.data(),
591          Value.size());
592   D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';
593 }
594 
VisitTranslationUnitDecl(TranslationUnitDecl * TU)595 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
596   llvm_unreachable("Translation units are not serialized");
597 }
598 
VisitNamedDecl(NamedDecl * ND)599 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
600   VisitDecl(ND);
601   ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
602   AnonymousDeclNumber = Record[Idx++];
603 }
604 
VisitTypeDecl(TypeDecl * TD)605 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
606   VisitNamedDecl(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++]);
610 }
611 
612 ASTDeclReader::RedeclarableResult
VisitTypedefNameDecl(TypedefNameDecl * TD)613 ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
614   RedeclarableResult Redecl = VisitRedeclarable(TD);
615   VisitTypeDecl(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);
620   } else
621     TD->setTypeSourceInfo(TInfo);
622   return Redecl;
623 }
624 
VisitTypedefDecl(TypedefDecl * TD)625 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
626   RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
627   mergeRedeclarable(TD, Redecl);
628 }
629 
VisitTypeAliasDecl(TypeAliasDecl * TD)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);
635   else
636     mergeRedeclarable(TD, Redecl);
637 }
638 
VisitTagDecl(TagDecl * TD)639 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
640   RedeclarableResult Redecl = VisitRedeclarable(TD);
641   VisitTypeDecl(TD);
642 
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->setRBraceLoc(ReadSourceLocation(Record, Idx));
651 
652   switch (Record[Idx++]) {
653   case 0:
654     break;
655   case 1: { // ExtInfo
656     TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
657     ReadQualifierInfo(*Info, Record, Idx);
658     TD->TypedefNameDeclOrQualifier = Info;
659     break;
660   }
661   case 2: // TypedefNameForAnonDecl
662     NamedDeclForTagDecl = ReadDeclID(Record, Idx);
663     TypedefNameForLinkage = Reader.GetIdentifierInfo(F, Record, Idx);
664     break;
665   default:
666     llvm_unreachable("unexpected tag info kind");
667   }
668 
669   if (!isa<CXXRecordDecl>(TD))
670     mergeRedeclarable(TD, Redecl);
671   return Redecl;
672 }
673 
VisitEnumDecl(EnumDecl * ED)674 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
675   VisitTagDecl(ED);
676   if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
677     ED->setIntegerTypeSourceInfo(TI);
678   else
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++];
686 
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()];
693     if (!OldDef) {
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()) {
698           OldDef = D;
699           break;
700         }
701       }
702     }
703     if (OldDef) {
704       Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
705       ED->IsCompleteDefinition = false;
706       mergeDefinitionVisibility(OldDef, ED);
707     } else {
708       OldDef = ED;
709     }
710   }
711 
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);
717   }
718 }
719 
720 ASTDeclReader::RedeclarableResult
VisitRecordDeclImpl(RecordDecl * RD)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++]);
727   return Redecl;
728 }
729 
VisitValueDecl(ValueDecl * VD)730 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
731   VisitNamedDecl(VD);
732   VD->setType(Reader.readType(F, Record, Idx));
733 }
734 
VisitEnumConstantDecl(EnumConstantDecl * ECD)735 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
736   VisitValueDecl(ECD);
737   if (Record[Idx++])
738     ECD->setInitExpr(Reader.ReadExpr(F));
739   ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
740   mergeMergeable(ECD);
741 }
742 
VisitDeclaratorDecl(DeclaratorDecl * DD)743 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
744   VisitValueDecl(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);
750     DD->DeclInfo = Info;
751   }
752 }
753 
VisitFunctionDecl(FunctionDecl * FD)754 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
755   RedeclarableResult Redecl = VisitRedeclarable(FD);
756   VisitDeclaratorDecl(FD);
757 
758   ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
759   FD->IdentifierNamespace = Record[Idx++];
760 
761   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
762   // after everything else is read.
763 
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);
781 
782   switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
783   case FunctionDecl::TK_NonTemplate:
784     mergeRedeclarable(FD, Redecl);
785     break;
786   case FunctionDecl::TK_FunctionTemplate:
787     // Merged when we merge the template.
788     FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
789                                                                       Idx));
790     break;
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);
798     break;
799   }
800   case FunctionDecl::TK_FunctionTemplateSpecialization: {
801     FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
802                                                                       Idx);
803     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
804 
805     // Template arguments.
806     SmallVector<TemplateArgument, 8> TemplArgs;
807     Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
808                                     /*Canonicalize*/ true);
809 
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));
820 
821       LAngleLoc = ReadSourceLocation(Record, Idx);
822       RAngleLoc = ReadSourceLocation(Record, Idx);
823     }
824 
825     SourceLocation POI = ReadSourceLocation(Record, Idx);
826 
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,
835                                                      TemplArgList,
836                              HasTemplateArgumentsAsWritten ? &TemplArgsInfo
837                                                            : nullptr,
838                                                      POI);
839     FD->TemplateOrSpecialization = FTInfo;
840 
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
850       // be initializing.
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);
857       if (InsertPos)
858         CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
859       else {
860         assert(Reader.getContext().getLangOpts().Modules &&
861                "already deserialized this template specialization");
862         mergeRedeclarable(FD, ExistingInfo->Function, Redecl);
863       }
864     }
865     break;
866   }
867   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
868     // Templates.
869     UnresolvedSet<8> TemplDecls;
870     unsigned NumTemplates = Record[Idx++];
871     while (NumTemplates--)
872       TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
873 
874     // Templates args.
875     TemplateArgumentListInfo TemplArgs;
876     unsigned NumArgs = Record[Idx++];
877     while (NumArgs--)
878       TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
879     TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
880     TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
881 
882     FD->setDependentTemplateSpecialization(Reader.getContext(),
883                                            TemplDecls, TemplArgs);
884     // These are not merged; we don't need to merge redeclarations of dependent
885     // template friends.
886     break;
887   }
888   }
889 
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);
897 }
898 
VisitObjCMethodDecl(ObjCMethodDecl * MD)899 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
900   VisitNamedDecl(MD);
901   if (Record[Idx++]) {
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));
908   }
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++];
915 
916   MD->IsRedeclaration = Record[Idx++];
917   MD->HasRedeclaration = Record[Idx++];
918   if (MD->HasRedeclaration)
919     Reader.getContext().setObjCMethodRedeclaration(MD,
920                                        ReadDeclAs<ObjCMethodDecl>(Record, Idx));
921 
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));
933 
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));
940 
941   MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
942 }
943 
VisitObjCTypeParamDecl(ObjCTypeParamDecl * D)944 void ASTDeclReader::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
945   VisitTypedefNameDecl(D);
946 
947   D->Variance = Record[Idx++];
948   D->Index = Record[Idx++];
949   D->VarianceLoc = ReadSourceLocation(Record, Idx);
950   D->ColonLoc = ReadSourceLocation(Record, Idx);
951 }
952 
VisitObjCContainerDecl(ObjCContainerDecl * CD)953 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
954   VisitNamedDecl(CD);
955   CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
956   CD->setAtEndRange(ReadSourceRange(Record, Idx));
957 }
958 
ReadObjCTypeParamList()959 ObjCTypeParamList *ASTDeclReader::ReadObjCTypeParamList() {
960   unsigned numParams = Record[Idx++];
961   if (numParams == 0)
962     return nullptr;
963 
964   SmallVector<ObjCTypeParamDecl *, 4> typeParams;
965   typeParams.reserve(numParams);
966   for (unsigned i = 0; i != numParams; ++i) {
967     auto typeParam = ReadDeclAs<ObjCTypeParamDecl>(Record, Idx);
968     if (!typeParam)
969       return nullptr;
970 
971     typeParams.push_back(typeParam);
972   }
973 
974   SourceLocation lAngleLoc = ReadSourceLocation(Record, Idx);
975   SourceLocation rAngleLoc = ReadSourceLocation(Record, Idx);
976 
977   return ObjCTypeParamList::create(Reader.getContext(), lAngleLoc,
978                                    typeParams, rAngleLoc);
979 }
980 
VisitObjCInterfaceDecl(ObjCInterfaceDecl * ID)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);
986 
987   ID->TypeParamList = ReadObjCTypeParamList();
988   if (Record[Idx++]) {
989     // Read the definition.
990     ID->allocateDefinitionData();
991 
992     // Set the definition data of the canonical declaration, so other
993     // redeclarations will see it.
994     ID->getCanonicalDecl()->Data = ID->Data;
995 
996     ObjCInterfaceDecl::DefinitionData &Data = ID->data();
997 
998     // Read the superclass.
999     Data.SuperClassTInfo = GetTypeSourceInfo(Record, Idx);
1000 
1001     Data.EndLoc = ReadSourceLocation(Record, Idx);
1002     Data.HasDesignatedInitializers = Record[Idx++];
1003 
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());
1016 
1017     // Read the transitive closure of protocols referenced by this class.
1018     NumProtocols = Record[Idx++];
1019     Protocols.clear();
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());
1025 
1026     // We will rebuild this list lazily.
1027     ID->setIvarList(nullptr);
1028 
1029     // Note that we have deserialized a definition.
1030     Reader.PendingDefinitions.insert(ID);
1031 
1032     // Note that we've loaded this Objective-C class.
1033     Reader.ObjCClassesLoaded.push_back(ID);
1034   } else {
1035     ID->Data = ID->getCanonicalDecl()->Data;
1036   }
1037 }
1038 
VisitObjCIvarDecl(ObjCIvarDecl * IVD)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);
1046 }
1047 
VisitObjCProtocolDecl(ObjCProtocolDecl * PD)1048 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
1049   RedeclarableResult Redecl = VisitRedeclarable(PD);
1050   VisitObjCContainerDecl(PD);
1051   mergeRedeclarable(PD, Redecl);
1052 
1053   if (Record[Idx++]) {
1054     // Read the definition.
1055     PD->allocateDefinitionData();
1056 
1057     // Set the definition data of the canonical declaration, so other
1058     // redeclarations will see it.
1059     PD->getCanonicalDecl()->Data = PD->Data;
1060 
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());
1072 
1073     // Note that we have deserialized a definition.
1074     Reader.PendingDefinitions.insert(PD);
1075   } else {
1076     PD->Data = PD->getCanonicalDecl()->Data;
1077   }
1078 }
1079 
VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl * FD)1080 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
1081   VisitFieldDecl(FD);
1082 }
1083 
VisitObjCCategoryDecl(ObjCCategoryDecl * CD)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));
1089 
1090   // Note that this category has been deserialized. We do this before
1091   // deserializing the interface declaration, so that it will consider this
1092   /// category.
1093   Reader.CategoriesDeserialized.insert(CD);
1094 
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());
1108 }
1109 
VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl * CAD)1110 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
1111   VisitNamedDecl(CAD);
1112   CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1113 }
1114 
VisitObjCPropertyDecl(ObjCPropertyDecl * D)1115 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
1116   VisitNamedDecl(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);
1121   D->setType(T, TSI);
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));
1133 }
1134 
VisitObjCImplDecl(ObjCImplDecl * D)1135 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
1136   VisitObjCContainerDecl(D);
1137   D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1138 }
1139 
VisitObjCCategoryImplDecl(ObjCCategoryImplDecl * D)1140 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1141   VisitObjCImplDecl(D);
1142   D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
1143   D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
1144 }
1145 
VisitObjCImplementationDecl(ObjCImplementationDecl * D)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);
1157 }
1158 
VisitObjCPropertyImplDecl(ObjCPropertyImplDecl * D)1159 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
1160   VisitDecl(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));
1167 }
1168 
VisitFieldDecl(FieldDecl * FD)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());
1179     } else {
1180       FD->InitStorage.setPointer(Reader.ReadExpr(F));
1181     }
1182   }
1183   if (!FD->getDeclName()) {
1184     if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
1185       Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
1186   }
1187   mergeMergeable(FD);
1188 }
1189 
VisitMSPropertyDecl(MSPropertyDecl * PD)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);
1194 }
1195 
VisitIndirectFieldDecl(IndirectFieldDecl * FD)1196 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
1197   VisitValueDecl(FD);
1198 
1199   FD->ChainingSize = Record[Idx++];
1200   assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1201   FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
1202 
1203   for (unsigned I = 0; I != FD->ChainingSize; ++I)
1204     FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
1205 
1206   mergeMergeable(FD);
1207 }
1208 
VisitVarDeclImpl(VarDecl * VD)1209 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
1210   RedeclarableResult Redecl = VisitRedeclarable(VD);
1211   VisitDeclaratorDecl(VD);
1212 
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++];
1226   }
1227   Linkage VarLinkage = Linkage(Record[Idx++]);
1228   VD->setCachedLinkage(VarLinkage);
1229 
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();
1234 
1235   if (uint64_t Val = Record[Idx++]) {
1236     VD->setInit(Reader.ReadExpr(F));
1237     if (Val > 1) {
1238       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1239       Eval->CheckedICE = true;
1240       Eval->IsICE = Val == 3;
1241     }
1242   }
1243 
1244   enum VarKind {
1245     VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1246   };
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);
1254     break;
1255   case VarTemplate:
1256     // Merged when we merge the template.
1257     VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
1258     break;
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);
1265     break;
1266   }
1267   }
1268 
1269   return Redecl;
1270 }
1271 
VisitImplicitParamDecl(ImplicitParamDecl * PD)1272 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
1273   VisitVarDecl(PD);
1274 }
1275 
VisitParmVarDecl(ParmVarDecl * PD)1276 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
1277   VisitVarDecl(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;
1286   } else {
1287     PD->setScopeInfo(scopeDepth, scopeIndex);
1288   }
1289   PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
1290   PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
1291   if (Record[Idx++]) // hasUninstantiatedDefaultArg.
1292     PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
1293 
1294   // FIXME: If this is a redeclaration of a function from another module, handle
1295   // inheritance of default arguments.
1296 }
1297 
VisitFileScopeAsmDecl(FileScopeAsmDecl * AD)1298 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
1299   VisitDecl(AD);
1300   AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
1301   AD->setRParenLoc(ReadSourceLocation(Record, Idx));
1302 }
1303 
VisitBlockDecl(BlockDecl * BD)1304 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
1305   VisitDecl(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);
1314 
1315   BD->setIsVariadic(Record[Idx++]);
1316   BD->setBlockMissingReturnType(Record[Idx++]);
1317   BD->setIsConversionFromLambda(Record[Idx++]);
1318 
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);
1329 
1330     captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
1331   }
1332   BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);
1333 }
1334 
VisitCapturedDecl(CapturedDecl * CD)1335 void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
1336   VisitDecl(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));
1343     else
1344       CD->setContextParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1345   }
1346 }
1347 
VisitLinkageSpecDecl(LinkageSpecDecl * D)1348 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1349   VisitDecl(D);
1350   D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
1351   D->setExternLoc(ReadSourceLocation(Record, Idx));
1352   D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1353 }
1354 
VisitLabelDecl(LabelDecl * D)1355 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1356   VisitNamedDecl(D);
1357   D->setLocStart(ReadSourceLocation(Record, Idx));
1358 }
1359 
VisitNamespaceDecl(NamespaceDecl * D)1360 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1361   RedeclarableResult Redecl = VisitRedeclarable(D);
1362   VisitNamedDecl(D);
1363   D->setInline(Record[Idx++]);
1364   D->LocStart = ReadSourceLocation(Record, Idx);
1365   D->RBraceLoc = ReadSourceLocation(Record, Idx);
1366 
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);
1374   } else {
1375     // Link this namespace back to the first declaration, which has already
1376     // been deserialized.
1377     D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
1378   }
1379 
1380   mergeRedeclarable(D, Redecl);
1381 
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);
1389   }
1390 }
1391 
VisitNamespaceAliasDecl(NamespaceAliasDecl * D)1392 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1393   RedeclarableResult Redecl = VisitRedeclarable(D);
1394   VisitNamedDecl(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);
1400 }
1401 
VisitUsingDecl(UsingDecl * D)1402 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1403   VisitNamedDecl(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);
1411   mergeMergeable(D);
1412 }
1413 
VisitUsingShadowDecl(UsingShadowDecl * D)1414 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1415   RedeclarableResult Redecl = VisitRedeclarable(D);
1416   VisitNamedDecl(D);
1417   D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1418   D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1419   UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1420   if (Pattern)
1421     Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1422   mergeRedeclarable(D, Redecl);
1423 }
1424 
VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl * D)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++];
1433 }
1434 
VisitUsingDirectiveDecl(UsingDirectiveDecl * D)1435 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1436   VisitNamedDecl(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);
1442 }
1443 
VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl * D)1444 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1445   VisitValueDecl(D);
1446   D->setUsingLoc(ReadSourceLocation(Record, Idx));
1447   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1448   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1449   mergeMergeable(D);
1450 }
1451 
VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl * D)1452 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1453                                                UnresolvedUsingTypenameDecl *D) {
1454   VisitTypeDecl(D);
1455   D->TypenameLocation = ReadSourceLocation(Record, Idx);
1456   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1457   mergeMergeable(D);
1458 }
1459 
ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData & Data,const RecordData & Record,unsigned & 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++];
1505 
1506   Data.NumBases = Record[Idx++];
1507   if (Data.NumBases)
1508     Data.Bases = ReadGlobalOffset(F, Record, Idx);
1509   Data.NumVBases = Record[Idx++];
1510   if (Data.NumVBases)
1511     Data.VBases = ReadGlobalOffset(F, Record, Idx);
1512 
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);
1517 
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);
1529     Lambda.Captures
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++]);
1537       switch (Kind) {
1538       case LCK_StarThis:
1539       case LCK_This:
1540       case LCK_VLAType:
1541         *ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
1542         break;
1543       case LCK_ByCopy:
1544       case LCK_ByRef:
1545         VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1546         SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1547         *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1548         break;
1549       }
1550     }
1551   }
1552 }
1553 
MergeDefinitionData(CXXRecordDecl * D,struct CXXRecordDecl::DefinitionData && MergeDD)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;
1559 
1560   if (DD.Definition != MergeDD.Definition) {
1561     // Track that we merged the definitions.
1562     Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,
1563                                                     DD.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");
1569   }
1570 
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;
1578 
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;
1584     return;
1585   }
1586 
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; \
1592     OR_FIELD(Field)
1593   MATCH_FIELD(UserDeclaredConstructor)
1594   MATCH_FIELD(UserDeclaredSpecialMembers)
1595   MATCH_FIELD(Aggregate)
1596   MATCH_FIELD(PlainOldData)
1597   MATCH_FIELD(Empty)
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)
1635 #undef OR_FIELD
1636 #undef MATCH_FIELD
1637 
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.
1642 
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;
1648   }
1649 
1650   // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
1651   // lazily load it.
1652 
1653   if (DD.IsLambda) {
1654     // FIXME: ODR-checking for merging lambdas (this happens, for instance,
1655     // when they occur within the body of a function template specialization).
1656   }
1657 
1658   if (DetectedOdrViolation)
1659     Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
1660 }
1661 
ReadCXXRecordDefinition(CXXRecordDecl * D,bool Update)1662 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update) {
1663   struct CXXRecordDecl::DefinitionData *DD;
1664   ASTContext &C = Reader.getContext();
1665 
1666   // Determine whether this is a lambda closure type, so that we can
1667   // allocate the appropriate DefinitionData structure.
1668   bool IsLambda = Record[Idx++];
1669   if (IsLambda)
1670     DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
1671                                                      LCD_None);
1672   else
1673     DD = new (C) struct CXXRecordDecl::DefinitionData(D);
1674 
1675   ReadCXXDefinitionData(*DD, Record, Idx);
1676 
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;
1684     return;
1685   }
1686 
1687   // Mark this declaration as being a definition.
1688   D->IsCompleteDefinition = true;
1689   D->DefinitionData = DD;
1690 
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);
1697   }
1698 }
1699 
1700 ASTDeclReader::RedeclarableResult
VisitCXXRecordDeclImpl(CXXRecordDecl * D)1701 ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
1702   RedeclarableResult Redecl = VisitRecordDeclImpl(D);
1703 
1704   ASTContext &C = Reader.getContext();
1705 
1706   enum CXXRecKind {
1707     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1708   };
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);
1714     break;
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).
1723       //
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;
1727     }
1728     break;
1729   }
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);
1738     break;
1739   }
1740   }
1741 
1742   bool WasDefinition = Record[Idx++];
1743   if (WasDefinition)
1744     ReadCXXRecordDefinition(D, /*Update*/false);
1745   else
1746     // Propagate DefinitionData pointer from the canonical declaration.
1747     D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1748 
1749   // Lazily load the key function to avoid deserializing every method so we can
1750   // compute it.
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;
1758   }
1759 
1760   return Redecl;
1761 }
1762 
VisitCXXMethodDecl(CXXMethodDecl * D)1763 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1764   VisitFunctionDecl(D);
1765 
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());
1773     }
1774   } else {
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;
1778   }
1779 }
1780 
VisitCXXConstructorDecl(CXXConstructorDecl * D)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);
1789   }
1790 
1791   VisitCXXMethodDecl(D);
1792 
1793   D->IsExplicitSpecified = Record[Idx++];
1794 }
1795 
VisitCXXDestructorDecl(CXXDestructorDecl * D)1796 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1797   VisitCXXMethodDecl(D);
1798 
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;
1804   }
1805 }
1806 
VisitCXXConversionDecl(CXXConversionDecl * D)1807 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1808   VisitCXXMethodDecl(D);
1809   D->IsExplicitSpecified = Record[Idx++];
1810 }
1811 
VisitImportDecl(ImportDecl * D)1812 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1813   VisitDecl(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.
1820 }
1821 
VisitAccessSpecDecl(AccessSpecDecl * D)1822 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1823   VisitDecl(D);
1824   D->setColonLoc(ReadSourceLocation(Record, Idx));
1825 }
1826 
VisitFriendDecl(FriendDecl * D)1827 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1828   VisitDecl(D);
1829   if (Record[Idx++]) // hasFriendDecl
1830     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1831   else
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);
1839 }
1840 
VisitFriendTemplateDecl(FriendTemplateDecl * D)1841 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1842   VisitDecl(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);
1850   else
1851     D->Friend = GetTypeSourceInfo(Record, Idx);
1852   D->FriendLoc = ReadSourceLocation(Record, Idx);
1853 }
1854 
VisitTemplateDecl(TemplateDecl * D)1855 DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1856   VisitNamedDecl(D);
1857 
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);
1863 
1864   return PatternID;
1865 }
1866 
1867 ASTDeclReader::RedeclarableResult
VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl * D)1868 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1869   RedeclarableResult Redecl = VisitRedeclarable(D);
1870 
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);
1877   }
1878   D->Common = CanonD->Common;
1879 
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);
1888       if (Record[Idx++])
1889         D->setMemberSpecialization();
1890     }
1891   }
1892 
1893   DeclID PatternID = VisitTemplateDecl(D);
1894   D->IdentifierNamespace = Record[Idx++];
1895 
1896   mergeRedeclarable(D, Redecl, PatternID);
1897 
1898   // If we merged the template with a prior declaration chain, merge the common
1899   // pointer.
1900   // FIXME: Actually merge here, don't just overwrite.
1901   D->Common = D->getCanonicalDecl()->Common;
1902 
1903   return Redecl;
1904 }
1905 
newDeclIDList(ASTContext & Context,DeclID * Old,SmallVectorImpl<DeclID> & IDs)1906 static DeclID *newDeclIDList(ASTContext &Context, DeclID *Old,
1907                              SmallVectorImpl<DeclID> &IDs) {
1908   assert(!IDs.empty() && "no IDs to add to list");
1909   if (Old) {
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());
1913   }
1914 
1915   auto *Result = new (Context) DeclID[1 + IDs.size()];
1916   *Result = IDs.size();
1917   std::copy(IDs.begin(), IDs.end(), Result + 1);
1918   return Result;
1919 }
1920 
VisitClassTemplateDecl(ClassTemplateDecl * D)1921 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1922   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1923 
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);
1929 
1930     if (!SpecIDs.empty()) {
1931       auto *CommonPtr = D->getCommonPtr();
1932       CommonPtr->LazySpecializations = newDeclIDList(
1933           Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
1934     }
1935   }
1936 
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
1940     // it now.
1941     Reader.Context.getInjectedClassNameType(
1942         D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
1943   }
1944 }
1945 
VisitBuiltinTemplateDecl(BuiltinTemplateDecl * D)1946 void ASTDeclReader::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
1947   llvm_unreachable("BuiltinTemplates are not serialized");
1948 }
1949 
1950 /// TODO: Unify with ClassTemplateDecl version?
1951 ///       May require unifying ClassTemplateDecl and
1952 ///        VarTemplateDecl beyond TemplateDecl...
VisitVarTemplateDecl(VarTemplateDecl * D)1953 void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
1954   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1955 
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);
1961 
1962     if (!SpecIDs.empty()) {
1963       auto *CommonPtr = D->getCommonPtr();
1964       CommonPtr->LazySpecializations = newDeclIDList(
1965           Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
1966     }
1967   }
1968 }
1969 
1970 ASTDeclReader::RedeclarableResult
VisitClassTemplateSpecializationDeclImpl(ClassTemplateSpecializationDecl * D)1971 ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
1972     ClassTemplateSpecializationDecl *D) {
1973   RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
1974 
1975   ASTContext &C = Reader.getContext();
1976   if (Decl *InstD = ReadDecl(Record, Idx)) {
1977     if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1978       D->SpecializedTemplate = CTD;
1979     } else {
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;
1991     }
1992   }
1993 
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++];
2000 
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);
2011       } else {
2012         CanonSpec =
2013             CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2014       }
2015       // If there was already a canonical specialization, merge into it.
2016       if (CanonSpec != D) {
2017         mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
2018 
2019         // This declaration might be a definition. Merge with any existing
2020         // definition.
2021         if (auto *DDD = D->DefinitionData) {
2022           if (CanonSpec->DefinitionData)
2023             MergeDefinitionData(CanonSpec, std::move(*DDD));
2024           else
2025             CanonSpec->DefinitionData = D->DefinitionData;
2026         }
2027         D->DefinitionData = CanonSpec->DefinitionData;
2028       }
2029     }
2030   }
2031 
2032   // Explicit info.
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;
2040   }
2041 
2042   return Redecl;
2043 }
2044 
VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl * D)2045 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
2046                                     ClassTemplatePartialSpecializationDecl *D) {
2047   RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
2048 
2049   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
2050   D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
2051 
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++]);
2057   }
2058 }
2059 
VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl * D)2060 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
2061                                     ClassScopeFunctionSpecializationDecl *D) {
2062   VisitDecl(D);
2063   D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
2064 }
2065 
VisitFunctionTemplateDecl(FunctionTemplateDecl * D)2066 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
2067   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2068 
2069   if (ThisDeclID == Redecl.getFirstID()) {
2070     // This FunctionTemplateDecl owns a CommonPtr; read it.
2071     SmallVector<serialization::DeclID, 32> SpecIDs;
2072     ReadDeclIDList(SpecIDs);
2073 
2074     if (!SpecIDs.empty()) {
2075       auto *CommonPtr = D->getCommonPtr();
2076       CommonPtr->LazySpecializations = newDeclIDList(
2077           Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
2078     }
2079   }
2080 }
2081 
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
VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl * D)2088 ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
2089     VarTemplateSpecializationDecl *D) {
2090   RedeclarableResult Redecl = VisitVarDeclImpl(D);
2091 
2092   ASTContext &C = Reader.getContext();
2093   if (Decl *InstD = ReadDecl(Record, Idx)) {
2094     if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
2095       D->SpecializedTemplate = VTD;
2096     } else {
2097       SmallVector<TemplateArgument, 8> TemplArgs;
2098       Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
2099       TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
2100           C, TemplArgs);
2101       VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
2102           new (C)
2103           VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
2104       PS->PartialSpecialization =
2105           cast<VarTemplatePartialSpecializationDecl>(InstD);
2106       PS->TemplateArgs = ArgList;
2107       D->SpecializedTemplate = PS;
2108     }
2109   }
2110 
2111   // Explicit info.
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;
2119   }
2120 
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++];
2127 
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);
2137       } else {
2138         CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2139       }
2140     }
2141   }
2142 
2143   return Redecl;
2144 }
2145 
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.
VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl * D)2151 void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
2152     VarTemplatePartialSpecializationDecl *D) {
2153   RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
2154 
2155   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
2156   D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
2157 
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++]);
2163   }
2164 }
2165 
VisitTemplateTypeParmDecl(TemplateTypeParmDecl * D)2166 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
2167   VisitTypeDecl(D);
2168 
2169   D->setDeclaredWithTypename(Record[Idx++]);
2170 
2171   if (Record[Idx++])
2172     D->setDefaultArgument(GetTypeSourceInfo(Record, Idx));
2173 }
2174 
VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl * D)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);
2186     }
2187   } else {
2188     // Rest of NonTypeTemplateParmDecl.
2189     D->ParameterPack = Record[Idx++];
2190     if (Record[Idx++])
2191       D->setDefaultArgument(Reader.ReadExpr(F));
2192   }
2193 }
2194 
VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl * D)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();
2204          I != N; ++I)
2205       Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
2206   } else {
2207     // Rest of TemplateTemplateParmDecl.
2208     D->ParameterPack = Record[Idx++];
2209     if (Record[Idx++])
2210       D->setDefaultArgument(Reader.getContext(),
2211                             Reader.ReadTemplateArgumentLoc(F, Record, Idx));
2212   }
2213 }
2214 
VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl * D)2215 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2216   VisitRedeclarableTemplateDecl(D);
2217 }
2218 
VisitStaticAssertDecl(StaticAssertDecl * D)2219 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
2220   VisitDecl(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);
2225 }
2226 
VisitEmptyDecl(EmptyDecl * D)2227 void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
2228   VisitDecl(D);
2229 }
2230 
2231 std::pair<uint64_t, uint64_t>
VisitDeclContext(DeclContext * DC)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);
2236 }
2237 
2238 template <typename T>
2239 ASTDeclReader::RedeclarableResult
VisitRedeclarable(Redeclarable<T> * D)2240 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
2241   DeclID FirstDeclID = ReadDeclID(Record, Idx);
2242   Decl *MergeWith = nullptr;
2243 
2244   bool IsKeyDecl = ThisDeclID == FirstDeclID;
2245   bool IsFirstLocalDecl = false;
2246 
2247   uint64_t RedeclOffset = 0;
2248 
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;
2253     IsKeyDecl = true;
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.
2258     IsKeyDecl = N == 1;
2259     IsFirstLocalDecl = true;
2260 
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
2263     // them.
2264     // FIXME: Provide a known merge target to the second and subsequent such
2265     // declaration.
2266     for (unsigned I = 0; I != N - 1; ++I)
2267       MergeWith = ReadDecl(Record, Idx/*, MergeWith*/);
2268 
2269     RedeclOffset = ReadLocalOffset(Record, Idx);
2270   } else {
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);
2274   }
2275 
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();
2284   }
2285 
2286   T *DAsT = static_cast<T*>(D);
2287 
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
2291   // order.
2292   if (IsFirstLocalDecl)
2293     Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));
2294 
2295   return RedeclarableResult(FirstDeclID, MergeWith, IsKeyDecl);
2296 }
2297 
2298 /// \brief Attempts to merge the given declaration (D) with another declaration
2299 /// of the same entity.
2300 template<typename T>
mergeRedeclarable(Redeclarable<T> * DBase,RedeclarableResult & Redecl,DeclID TemplatePatternID)2301 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
2302                                       RedeclarableResult &Redecl,
2303                                       DeclID TemplatePatternID) {
2304   T *D = static_cast<T*>(DBase);
2305 
2306   // If modules are not available, there is no reason to perform this merge.
2307   if (!Reader.getContext().getLangOpts().Modules)
2308     return;
2309 
2310   // If we're not the canonical declaration, we don't need to merge.
2311   if (!DBase->isFirstDecl())
2312     return;
2313 
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);
2320 }
2321 
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
2324 /// instantiations.
assert_cast(T t)2325 template<typename T> static T assert_cast(T t) { return t; }
assert_cast(...)2326 template<typename T> static T assert_cast(...) {
2327   llvm_unreachable("bad assert_cast");
2328 }
2329 
2330 /// \brief Merge together the pattern declarations from two template
2331 /// declarations.
mergeTemplatePattern(RedeclarableTemplateDecl * D,RedeclarableTemplateDecl * Existing,DeclID DsID,bool IsKeyDecl)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);
2339 
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));
2348       } else {
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);
2353       }
2354     }
2355     DClass->DefinitionData = ExistingClass->DefinitionData;
2356 
2357     return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
2358                              Result);
2359   }
2360   if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
2361     return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
2362                              Result);
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),
2367                              Result);
2368   llvm_unreachable("merged an unknown kind of redeclarable template");
2369 }
2370 
2371 /// \brief Attempts to merge the given declaration (D) with another declaration
2372 /// of the same entity.
2373 template<typename T>
mergeRedeclarable(Redeclarable<T> * DBase,T * Existing,RedeclarableResult & Redecl,DeclID TemplatePatternID)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");
2383 
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;
2390     D->Used = false;
2391 
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));
2398 
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());
2404 
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());
2408   }
2409 }
2410 
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>
mergeMergeable(Mergeable<T> * D)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)
2419     return;
2420 
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)
2425     return;
2426 
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());
2431 }
2432 
VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl * D)2433 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2434   VisitDecl(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));
2440   }
2441   D->setVars(Vars);
2442 }
2443 
VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl * D)2444 void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
2445   VisitValueDecl(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);
2450 }
2451 
VisitOMPCapturedExprDecl(OMPCapturedExprDecl * D)2452 void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
2453   VisitVarDecl(D);
2454 }
2455 
2456 //===----------------------------------------------------------------------===//
2457 // Attribute Reading
2458 //===----------------------------------------------------------------------===//
2459 
2460 /// \brief Reads attributes from the current stream position.
ReadAttributes(ModuleFile & F,AttrVec & Attrs,const RecordData & Record,unsigned & Idx)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);
2467 
2468 #include "clang/Serialization/AttrPCHRead.inc"
2469 
2470     assert(New && "Unable to decode attribute?");
2471     Attrs.push_back(New);
2472   }
2473 }
2474 
2475 //===----------------------------------------------------------------------===//
2476 // ASTReader Implementation
2477 //===----------------------------------------------------------------------===//
2478 
2479 /// \brief Note that we have loaded the declaration with the given
2480 /// Index.
2481 ///
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.
LoadedDecl(unsigned Index,Decl * D)2485 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
2486   assert(!DeclsLoaded[Index] && "Decl loaded twice?");
2487   DeclsLoaded[Index] = D;
2488 }
2489 
2490 
2491 /// \brief Determine whether the consumer will be interested in seeing
2492 /// this declaration (via HandleTopLevelDecl).
2493 ///
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.
isConsumerInterestedIn(Decl * D,bool HasBody)2497 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
2498   // An ObjCMethodDecl is never considered as "interesting" because its
2499   // implementation container always is.
2500 
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))
2507     return true;
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;
2515 
2516   return false;
2517 }
2518 
2519 /// \brief Get the correct cursor and offset for loading a declaration.
2520 ASTReader::RecordLocation
DeclCursorForID(DeclID ID,SourceLocation & Loc)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);
2529 }
2530 
getLocalBitOffset(uint64_t GlobalOffset)2531 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
2532   ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
2533     = GlobalBitOffsetsMap.find(GlobalOffset);
2534 
2535   assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
2536   return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
2537 }
2538 
getGlobalBitOffset(ModuleFile & M,uint32_t LocalOffset)2539 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
2540   return LocalOffset + M.GlobalBitOffset;
2541 }
2542 
2543 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2544                                         const TemplateParameterList *Y);
2545 
2546 /// \brief Determine whether two template parameters are similar enough
2547 /// that they may be used in declarations of the same template.
isSameTemplateParameter(const NamedDecl * X,const NamedDecl * Y)2548 static bool isSameTemplateParameter(const NamedDecl *X,
2549                                     const NamedDecl *Y) {
2550   if (X->getKind() != Y->getKind())
2551     return false;
2552 
2553   if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
2554     const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
2555     return TX->isParameterPack() == TY->isParameterPack();
2556   }
2557 
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());
2562   }
2563 
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());
2569 }
2570 
getNamespace(const NestedNameSpecifier * X)2571 static NamespaceDecl *getNamespace(const NestedNameSpecifier *X) {
2572   if (auto *NS = X->getAsNamespace())
2573     return NS;
2574   if (auto *NAS = X->getAsNamespaceAlias())
2575     return NAS->getNamespace();
2576   return nullptr;
2577 }
2578 
isSameQualifier(const NestedNameSpecifier * X,const NestedNameSpecifier * Y)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())
2584       return false;
2585   } else if (X->getKind() != Y->getKind())
2586     return false;
2587 
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())
2593       return false;
2594     break;
2595   case NestedNameSpecifier::Namespace:
2596   case NestedNameSpecifier::NamespaceAlias:
2597     // We've already checked that we named the same namespace.
2598     break;
2599   case NestedNameSpecifier::TypeSpec:
2600   case NestedNameSpecifier::TypeSpecWithTemplate:
2601     if (X->getAsType()->getCanonicalTypeInternal() !=
2602         Y->getAsType()->getCanonicalTypeInternal())
2603       return false;
2604     break;
2605   case NestedNameSpecifier::Global:
2606   case NestedNameSpecifier::Super:
2607     return true;
2608   }
2609 
2610   // Recurse into earlier portion of NNS, if any.
2611   auto *PX = X->getPrefix();
2612   auto *PY = Y->getPrefix();
2613   if (PX && PY)
2614     return isSameQualifier(PX, PY);
2615   return !PX && !PY;
2616 }
2617 
2618 /// \brief Determine whether two template parameter lists are similar enough
2619 /// that they may be used in declarations of the same template.
isSameTemplateParameterList(const TemplateParameterList * X,const TemplateParameterList * Y)2620 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2621                                         const TemplateParameterList *Y) {
2622   if (X->size() != Y->size())
2623     return false;
2624 
2625   for (unsigned I = 0, N = X->size(); I != N; ++I)
2626     if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
2627       return false;
2628 
2629   return true;
2630 }
2631 
2632 /// \brief Determine whether the two declarations refer to the same entity.
isSameEntity(NamedDecl * X,NamedDecl * Y)2633 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
2634   assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
2635 
2636   if (X == Y)
2637     return true;
2638 
2639   // Must be in the same context.
2640   if (!X->getDeclContext()->getRedeclContext()->Equals(
2641          Y->getDeclContext()->getRedeclContext()))
2642     return false;
2643 
2644   // Two typedefs refer to the same entity if they have the same underlying
2645   // type.
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());
2650 
2651   // Must have the same kind.
2652   if (X->getKind() != Y->getKind())
2653     return false;
2654 
2655   // Objective-C classes and protocols with the same name always match.
2656   if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
2657     return true;
2658 
2659   if (isa<ClassTemplateSpecializationDecl>(X)) {
2660     // No need to handle these here: we merge them when adding them to the
2661     // template.
2662     return false;
2663   }
2664 
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));
2673   }
2674 
2675   // Functions with the same type and linkage match.
2676   // FIXME: This needs to cope with merging of prototyped/non-prototyped
2677   // functions, etc.
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()))
2685         return false;
2686     }
2687     return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
2688       FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
2689   }
2690 
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()))
2697         return true;
2698 
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)
2707         return false;
2708       if (VarXTy->isIncompleteArrayType() || VarYTy->isIncompleteArrayType())
2709         return C.hasSameType(VarXTy->getElementType(), VarYTy->getElementType());
2710     }
2711     return false;
2712   }
2713 
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();
2718   }
2719 
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());
2728   }
2729 
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());
2735   }
2736 
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();
2742   }
2743 
2744   // Enumerators with the same name match.
2745   if (isa<EnumConstantDecl>(X))
2746     // FIXME: Also check the value is odr-equivalent.
2747     return true;
2748 
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();
2753   }
2754 
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();
2762   }
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();
2767   }
2768   if (auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(X))
2769     return isSameQualifier(
2770         UX->getQualifier(),
2771         cast<UnresolvedUsingTypenameDecl>(Y)->getQualifier());
2772 
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());
2777   }
2778 
2779   return false;
2780 }
2781 
2782 /// Find the context in which we should search for previous declarations when
2783 /// looking for declarations to merge.
getPrimaryContextForMerging(ASTReader & Reader,DeclContext * DC)2784 DeclContext *ASTDeclReader::getPrimaryContextForMerging(ASTReader &Reader,
2785                                                         DeclContext *DC) {
2786   if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
2787     return ND->getOriginalNamespace();
2788 
2789   if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2790     // Try to dig out the definition.
2791     auto *DD = RD->DefinitionData;
2792     if (!DD)
2793       DD = RD->getCanonicalDecl()->DefinitionData;
2794 
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.
2799     if (!DD) {
2800       DD = new (Reader.Context) struct CXXRecordDecl::DefinitionData(RD);
2801       RD->IsCompleteDefinition = true;
2802       RD->DefinitionData = DD;
2803       RD->getCanonicalDecl()->DefinitionData = DD;
2804 
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));
2808     }
2809 
2810     return DD->Definition;
2811   }
2812 
2813   if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
2814     return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition()
2815                                                       : nullptr;
2816 
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))
2820     return TU;
2821 
2822   return nullptr;
2823 }
2824 
~FindExistingResult()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));
2832     return;
2833   }
2834 
2835   if (!AddResult || Existing)
2836     return;
2837 
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()]
2847             .push_back(New);
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);
2852   }
2853 }
2854 
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.
getDeclForMerging(NamedDecl * Found,bool IsTypedefNameForLinkage)2858 static NamedDecl *getDeclForMerging(NamedDecl *Found,
2859                                     bool IsTypedefNameForLinkage) {
2860   if (!IsTypedefNameForLinkage)
2861     return Found;
2862 
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())
2867     return nullptr;
2868 
2869   if (auto *TND = dyn_cast<TypedefNameDecl>(Found))
2870     return TND->getAnonDeclWithTypedefName();
2871 
2872   return nullptr;
2873 }
2874 
getAnonymousDeclForMerging(ASTReader & Reader,DeclContext * DC,unsigned Index)2875 NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
2876                                                      DeclContext *DC,
2877                                                      unsigned Index) {
2878   // If the lexical context has been merged, look into the now-canonical
2879   // definition.
2880   if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2881     DC = Merged;
2882 
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];
2887 
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()));
2894       else
2895         Previous[Number] = cast<NamedDecl>(ND->getCanonicalDecl());
2896     });
2897   }
2898 
2899   return Index < Previous.size() ? Previous[Index] : nullptr;
2900 }
2901 
setAnonymousDeclForMerging(ASTReader & Reader,DeclContext * DC,unsigned Index,NamedDecl * D)2902 void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
2903                                                DeclContext *DC, unsigned Index,
2904                                                NamedDecl *D) {
2905   if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2906     DC = Merged;
2907 
2908   auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2909   if (Index >= Previous.size())
2910     Previous.resize(Index + 1);
2911   if (!Previous[Index])
2912     Previous[Index] = D;
2913 }
2914 
findExisting(NamedDecl * D)2915 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
2916   DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
2917                                                : D->getDeclName();
2918 
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);
2924     Result.suppress();
2925     return Result;
2926   }
2927 
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.
2938   }
2939 
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();
2951 
2952     // Temporarily consider the identifier to be up-to-date. We don't want to
2953     // cause additional lookups here.
2954     class UpToDateIdentifierRAII {
2955       IdentifierInfo *II;
2956       bool WasOutToDate;
2957 
2958     public:
2959       explicit UpToDateIdentifierRAII(IdentifierInfo *II)
2960         : II(II), WasOutToDate(false)
2961       {
2962         if (II) {
2963           WasOutToDate = II->isOutOfDate();
2964           if (WasOutToDate)
2965             II->setOutOfDate(false);
2966         }
2967       }
2968 
2969       ~UpToDateIdentifierRAII() {
2970         if (WasOutToDate)
2971           II->setOutOfDate(true);
2972       }
2973     } UpToDate(Name.getAsIdentifierInfo());
2974 
2975     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2976                                    IEnd = IdResolver.end();
2977          I != IEnd; ++I) {
2978       if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2979         if (isSameEntity(Existing, D))
2980           return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2981                                     TypedefNameForLinkage);
2982     }
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);
2990     }
2991   } else {
2992     // Not in a mergeable context.
2993     return FindExistingResult(Reader);
2994   }
2995 
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.
2998   //
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);
3005 
3006   return FindExistingResult(Reader, D, /*Existing=*/nullptr,
3007                             AnonymousDeclNumber, TypedefNameForLinkage);
3008 }
3009 
3010 template<typename DeclT>
getMostRecentDeclImpl(Redeclarable<DeclT> * D)3011 Decl *ASTDeclReader::getMostRecentDeclImpl(Redeclarable<DeclT> *D) {
3012   return D->RedeclLink.getLatestNotUpdated();
3013 }
getMostRecentDeclImpl(...)3014 Decl *ASTDeclReader::getMostRecentDeclImpl(...) {
3015   llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");
3016 }
3017 
getMostRecentDecl(Decl * D)3018 Decl *ASTDeclReader::getMostRecentDecl(Decl *D) {
3019   assert(D);
3020 
3021   switch (D->getKind()) {
3022 #define ABSTRACT_DECL(TYPE)
3023 #define DECL(TYPE, BASE)                               \
3024   case Decl::TYPE:                                     \
3025     return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
3026 #include "clang/AST/DeclNodes.inc"
3027   }
3028   llvm_unreachable("unknown decl kind");
3029 }
3030 
getMostRecentExistingDecl(Decl * D)3031 Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
3032   return ASTDeclReader::getMostRecentDecl(D->getCanonicalDecl());
3033 }
3034 
3035 template<typename DeclT>
attachPreviousDeclImpl(ASTReader & Reader,Redeclarable<DeclT> * D,Decl * Previous,Decl * Canon)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;
3041 }
3042 
3043 namespace clang {
3044 template<>
attachPreviousDeclImpl(ASTReader & Reader,Redeclarable<FunctionDecl> * D,Decl * Previous,Decl * Canon)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);
3050 
3051   FD->RedeclLink.setPrevious(PrevFD);
3052   FD->First = PrevFD->First;
3053 
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.
3061     //
3062     // Be careful of this case:
3063     //
3064     // module A:
3065     //   template<typename T> struct X { void f(); };
3066     //   template<typename T> inline void X<T>::f() {}
3067     //
3068     // module B instantiates the declaration of X<int>::f
3069     // module C instantiates the definition of X<int>::f
3070     //
3071     // If module B and C are merged, we do not have a violation of this rule.
3072     FD->IsInline = true;
3073   }
3074 
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));
3086   }
3087 }
3088 } // end namespace clang
3089 
attachPreviousDeclImpl(ASTReader & Reader,...)3090 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) {
3091   llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
3092 }
3093 
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>
inheritDefaultTemplateArgument(ASTContext & Context,ParmDecl * From,Decl * ToD)3097 static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From,
3098                                            Decl *ToD) {
3099   auto *To = cast<ParmDecl>(ToD);
3100   if (!From->hasDefaultArgument())
3101     return false;
3102   To->setInheritedDefaultArgument(Context, From);
3103   return true;
3104 }
3105 
inheritDefaultTemplateArguments(ASTContext & Context,TemplateDecl * From,TemplateDecl * To)3106 static void inheritDefaultTemplateArguments(ASTContext &Context,
3107                                             TemplateDecl *From,
3108                                             TemplateDecl *To) {
3109   auto *FromTP = From->getTemplateParameters();
3110   auto *ToTP = To->getTemplateParameters();
3111   assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");
3112 
3113   for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {
3114     NamedDecl *FromParam = FromTP->getParam(N - I - 1);
3115     if (FromParam->isParameterPack())
3116       continue;
3117     NamedDecl *ToParam = ToTP->getParam(N - I - 1);
3118 
3119     if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(FromParam)) {
3120       if (!inheritDefaultTemplateArgument(Context, FTTP, ToParam))
3121         break;
3122     } else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(FromParam)) {
3123       if (!inheritDefaultTemplateArgument(Context, FNTTP, ToParam))
3124         break;
3125     } else {
3126       if (!inheritDefaultTemplateArgument(
3127               Context, cast<TemplateTemplateParmDecl>(FromParam), ToParam))
3128         break;
3129     }
3130   }
3131 }
3132 
attachPreviousDecl(ASTReader & Reader,Decl * D,Decl * Previous,Decl * Canon)3133 void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,
3134                                        Decl *Previous, Decl *Canon) {
3135   assert(D && Previous);
3136 
3137   switch (D->getKind()) {
3138 #define ABSTRACT_DECL(TYPE)
3139 #define DECL(TYPE, BASE)                                                  \
3140   case Decl::TYPE:                                                        \
3141     attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
3142     break;
3143 #include "clang/AST/DeclNodes.inc"
3144   }
3145 
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.
3148   //
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);
3154 
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);
3160 }
3161 
3162 template<typename DeclT>
attachLatestDeclImpl(Redeclarable<DeclT> * D,Decl * Latest)3163 void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
3164   D->RedeclLink.setLatest(cast<DeclT>(Latest));
3165 }
attachLatestDeclImpl(...)3166 void ASTDeclReader::attachLatestDeclImpl(...) {
3167   llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
3168 }
3169 
attachLatestDecl(Decl * D,Decl * Latest)3170 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
3171   assert(D && Latest);
3172 
3173   switch (D->getKind()) {
3174 #define ABSTRACT_DECL(TYPE)
3175 #define DECL(TYPE, BASE)                                  \
3176   case Decl::TYPE:                                        \
3177     attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
3178     break;
3179 #include "clang/AST/DeclNodes.inc"
3180   }
3181 }
3182 
3183 template<typename DeclT>
markIncompleteDeclChainImpl(Redeclarable<DeclT> * D)3184 void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
3185   D->RedeclLink.markIncomplete();
3186 }
markIncompleteDeclChainImpl(...)3187 void ASTDeclReader::markIncompleteDeclChainImpl(...) {
3188   llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
3189 }
3190 
markIncompleteDeclChain(Decl * D)3191 void ASTReader::markIncompleteDeclChain(Decl *D) {
3192   switch (D->getKind()) {
3193 #define ABSTRACT_DECL(TYPE)
3194 #define DECL(TYPE, BASE)                                             \
3195   case Decl::TYPE:                                                   \
3196     ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
3197     break;
3198 #include "clang/AST/DeclNodes.inc"
3199   }
3200 }
3201 
3202 /// \brief Read the declaration at the given offset from the AST file.
ReadDeclRecord(DeclID ID)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);
3211 
3212   ReadingKindTracker ReadingKind(Read_Decl, *this);
3213 
3214   // Note that we are loading a declaration record.
3215   Deserializing ADecl(this);
3216 
3217   DeclsCursor.JumpToBit(Loc.Offset);
3218   RecordData Record;
3219   unsigned Code = DeclsCursor.ReadCode();
3220   unsigned Idx = 0;
3221   ASTDeclReader Reader(*this, Loc, ID, DeclLoc, Record,Idx);
3222 
3223   Decl *D = nullptr;
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");
3228   case DECL_TYPEDEF:
3229     D = TypedefDecl::CreateDeserialized(Context, ID);
3230     break;
3231   case DECL_TYPEALIAS:
3232     D = TypeAliasDecl::CreateDeserialized(Context, ID);
3233     break;
3234   case DECL_ENUM:
3235     D = EnumDecl::CreateDeserialized(Context, ID);
3236     break;
3237   case DECL_RECORD:
3238     D = RecordDecl::CreateDeserialized(Context, ID);
3239     break;
3240   case DECL_ENUM_CONSTANT:
3241     D = EnumConstantDecl::CreateDeserialized(Context, ID);
3242     break;
3243   case DECL_FUNCTION:
3244     D = FunctionDecl::CreateDeserialized(Context, ID);
3245     break;
3246   case DECL_LINKAGE_SPEC:
3247     D = LinkageSpecDecl::CreateDeserialized(Context, ID);
3248     break;
3249   case DECL_LABEL:
3250     D = LabelDecl::CreateDeserialized(Context, ID);
3251     break;
3252   case DECL_NAMESPACE:
3253     D = NamespaceDecl::CreateDeserialized(Context, ID);
3254     break;
3255   case DECL_NAMESPACE_ALIAS:
3256     D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
3257     break;
3258   case DECL_USING:
3259     D = UsingDecl::CreateDeserialized(Context, ID);
3260     break;
3261   case DECL_USING_SHADOW:
3262     D = UsingShadowDecl::CreateDeserialized(Context, ID);
3263     break;
3264   case DECL_CONSTRUCTOR_USING_SHADOW:
3265     D = ConstructorUsingShadowDecl::CreateDeserialized(Context, ID);
3266     break;
3267   case DECL_USING_DIRECTIVE:
3268     D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
3269     break;
3270   case DECL_UNRESOLVED_USING_VALUE:
3271     D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
3272     break;
3273   case DECL_UNRESOLVED_USING_TYPENAME:
3274     D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
3275     break;
3276   case DECL_CXX_RECORD:
3277     D = CXXRecordDecl::CreateDeserialized(Context, ID);
3278     break;
3279   case DECL_CXX_METHOD:
3280     D = CXXMethodDecl::CreateDeserialized(Context, ID);
3281     break;
3282   case DECL_CXX_CONSTRUCTOR:
3283     D = CXXConstructorDecl::CreateDeserialized(Context, ID, false);
3284     break;
3285   case DECL_CXX_INHERITED_CONSTRUCTOR:
3286     D = CXXConstructorDecl::CreateDeserialized(Context, ID, true);
3287     break;
3288   case DECL_CXX_DESTRUCTOR:
3289     D = CXXDestructorDecl::CreateDeserialized(Context, ID);
3290     break;
3291   case DECL_CXX_CONVERSION:
3292     D = CXXConversionDecl::CreateDeserialized(Context, ID);
3293     break;
3294   case DECL_ACCESS_SPEC:
3295     D = AccessSpecDecl::CreateDeserialized(Context, ID);
3296     break;
3297   case DECL_FRIEND:
3298     D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3299     break;
3300   case DECL_FRIEND_TEMPLATE:
3301     D = FriendTemplateDecl::CreateDeserialized(Context, ID);
3302     break;
3303   case DECL_CLASS_TEMPLATE:
3304     D = ClassTemplateDecl::CreateDeserialized(Context, ID);
3305     break;
3306   case DECL_CLASS_TEMPLATE_SPECIALIZATION:
3307     D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
3308     break;
3309   case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
3310     D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
3311     break;
3312   case DECL_VAR_TEMPLATE:
3313     D = VarTemplateDecl::CreateDeserialized(Context, ID);
3314     break;
3315   case DECL_VAR_TEMPLATE_SPECIALIZATION:
3316     D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
3317     break;
3318   case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
3319     D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
3320     break;
3321   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
3322     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
3323     break;
3324   case DECL_FUNCTION_TEMPLATE:
3325     D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
3326     break;
3327   case DECL_TEMPLATE_TYPE_PARM:
3328     D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
3329     break;
3330   case DECL_NON_TYPE_TEMPLATE_PARM:
3331     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
3332     break;
3333   case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
3334     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3335     break;
3336   case DECL_TEMPLATE_TEMPLATE_PARM:
3337     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
3338     break;
3339   case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
3340     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
3341                                                      Record[Idx++]);
3342     break;
3343   case DECL_TYPE_ALIAS_TEMPLATE:
3344     D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
3345     break;
3346   case DECL_STATIC_ASSERT:
3347     D = StaticAssertDecl::CreateDeserialized(Context, ID);
3348     break;
3349   case DECL_OBJC_METHOD:
3350     D = ObjCMethodDecl::CreateDeserialized(Context, ID);
3351     break;
3352   case DECL_OBJC_INTERFACE:
3353     D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
3354     break;
3355   case DECL_OBJC_IVAR:
3356     D = ObjCIvarDecl::CreateDeserialized(Context, ID);
3357     break;
3358   case DECL_OBJC_PROTOCOL:
3359     D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
3360     break;
3361   case DECL_OBJC_AT_DEFS_FIELD:
3362     D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
3363     break;
3364   case DECL_OBJC_CATEGORY:
3365     D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
3366     break;
3367   case DECL_OBJC_CATEGORY_IMPL:
3368     D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
3369     break;
3370   case DECL_OBJC_IMPLEMENTATION:
3371     D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
3372     break;
3373   case DECL_OBJC_COMPATIBLE_ALIAS:
3374     D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
3375     break;
3376   case DECL_OBJC_PROPERTY:
3377     D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
3378     break;
3379   case DECL_OBJC_PROPERTY_IMPL:
3380     D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
3381     break;
3382   case DECL_FIELD:
3383     D = FieldDecl::CreateDeserialized(Context, ID);
3384     break;
3385   case DECL_INDIRECTFIELD:
3386     D = IndirectFieldDecl::CreateDeserialized(Context, ID);
3387     break;
3388   case DECL_VAR:
3389     D = VarDecl::CreateDeserialized(Context, ID);
3390     break;
3391   case DECL_IMPLICIT_PARAM:
3392     D = ImplicitParamDecl::CreateDeserialized(Context, ID);
3393     break;
3394   case DECL_PARM_VAR:
3395     D = ParmVarDecl::CreateDeserialized(Context, ID);
3396     break;
3397   case DECL_FILE_SCOPE_ASM:
3398     D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
3399     break;
3400   case DECL_BLOCK:
3401     D = BlockDecl::CreateDeserialized(Context, ID);
3402     break;
3403   case DECL_MS_PROPERTY:
3404     D = MSPropertyDecl::CreateDeserialized(Context, ID);
3405     break;
3406   case DECL_CAPTURED:
3407     D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3408     break;
3409   case DECL_CXX_BASE_SPECIFIERS:
3410     Error("attempt to read a C++ base-specifier record as a declaration");
3411     return nullptr;
3412   case DECL_CXX_CTOR_INITIALIZERS:
3413     Error("attempt to read a C++ ctor initializer record as a declaration");
3414     return nullptr;
3415   case DECL_IMPORT:
3416     // Note: last entry of the ImportDecl record is the number of stored source
3417     // locations.
3418     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
3419     break;
3420   case DECL_OMP_THREADPRIVATE:
3421     D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3422     break;
3423   case DECL_OMP_DECLARE_REDUCTION:
3424     D = OMPDeclareReductionDecl::CreateDeserialized(Context, ID);
3425     break;
3426   case DECL_OMP_CAPTUREDEXPR:
3427     D = OMPCapturedExprDecl::CreateDeserialized(Context, ID);
3428     break;
3429   case DECL_PRAGMA_COMMENT:
3430     D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3431     break;
3432   case DECL_PRAGMA_DETECT_MISMATCH:
3433     D = PragmaDetectMismatchDecl::CreateDeserialized(Context, ID,
3434                                                      Record[Idx++]);
3435     break;
3436   case DECL_EMPTY:
3437     D = EmptyDecl::CreateDeserialized(Context, ID);
3438     break;
3439   case DECL_OBJC_TYPE_PARAM:
3440     D = ObjCTypeParamDecl::CreateDeserialized(Context, ID);
3441     break;
3442   }
3443 
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());
3450   Reader.Visit(D);
3451 
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))
3458       return nullptr;
3459     if (Offsets.second &&
3460         ReadVisibleDeclContextStorage(*Loc.F, DeclsCursor, Offsets.second, ID))
3461       return nullptr;
3462   }
3463   assert(Idx == Record.size());
3464 
3465   // Load any relevant update records.
3466   PendingUpdateRecords.push_back(std::make_pair(ID, D));
3467 
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);
3472 
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);
3479 
3480   return D;
3481 }
3482 
loadDeclUpdateRecords(serialization::DeclID ID,Decl * 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   DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
3488   if (UpdI != DeclUpdateOffsets.end()) {
3489     auto UpdateOffsets = std::move(UpdI->second);
3490     DeclUpdateOffsets.erase(UpdI);
3491 
3492     bool WasInteresting = isConsumerInterestedIn(D, false);
3493     for (auto &FileAndOffset : UpdateOffsets) {
3494       ModuleFile *F = FileAndOffset.first;
3495       uint64_t Offset = FileAndOffset.second;
3496       llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3497       SavedStreamPosition SavedPosition(Cursor);
3498       Cursor.JumpToBit(Offset);
3499       RecordData Record;
3500       unsigned Code = Cursor.ReadCode();
3501       unsigned RecCode = Cursor.readRecord(Code, Record);
3502       (void)RecCode;
3503       assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
3504 
3505       unsigned Idx = 0;
3506       ASTDeclReader Reader(*this, RecordLocation(F, Offset), ID,
3507                            SourceLocation(), Record, Idx);
3508       Reader.UpdateDecl(D, *F, Record);
3509 
3510       // We might have made this declaration interesting. If so, remember that
3511       // we need to hand it off to the consumer.
3512       if (!WasInteresting &&
3513           isConsumerInterestedIn(D, Reader.hasPendingBody())) {
3514         InterestingDecls.push_back(D);
3515         WasInteresting = true;
3516       }
3517     }
3518   }
3519 
3520   // Load the pending visible updates for this decl context, if it has any.
3521   auto I = PendingVisibleUpdates.find(ID);
3522   if (I != PendingVisibleUpdates.end()) {
3523     auto VisibleUpdates = std::move(I->second);
3524     PendingVisibleUpdates.erase(I);
3525 
3526     auto *DC = cast<DeclContext>(D)->getPrimaryContext();
3527     for (const PendingVisibleUpdate &Update : VisibleUpdates)
3528       Lookups[DC].Table.add(
3529           Update.Mod, Update.Data,
3530           reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));
3531     DC->setHasExternalVisibleStorage(true);
3532   }
3533 }
3534 
loadPendingDeclChain(Decl * FirstLocal,uint64_t LocalOffset)3535 void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {
3536   // Attach FirstLocal to the end of the decl chain.
3537   Decl *CanonDecl = FirstLocal->getCanonicalDecl();
3538   if (FirstLocal != CanonDecl) {
3539     Decl *PrevMostRecent = ASTDeclReader::getMostRecentDecl(CanonDecl);
3540     ASTDeclReader::attachPreviousDecl(
3541         *this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,
3542         CanonDecl);
3543   }
3544 
3545   if (!LocalOffset) {
3546     ASTDeclReader::attachLatestDecl(CanonDecl, FirstLocal);
3547     return;
3548   }
3549 
3550   // Load the list of other redeclarations from this module file.
3551   ModuleFile *M = getOwningModuleFile(FirstLocal);
3552   assert(M && "imported decl from no module file");
3553 
3554   llvm::BitstreamCursor &Cursor = M->DeclsCursor;
3555   SavedStreamPosition SavedPosition(Cursor);
3556   Cursor.JumpToBit(LocalOffset);
3557 
3558   RecordData Record;
3559   unsigned Code = Cursor.ReadCode();
3560   unsigned RecCode = Cursor.readRecord(Code, Record);
3561   (void)RecCode;
3562   assert(RecCode == LOCAL_REDECLARATIONS && "expected LOCAL_REDECLARATIONS record!");
3563 
3564   // FIXME: We have several different dispatches on decl kind here; maybe
3565   // we should instead generate one loop per kind and dispatch up-front?
3566   Decl *MostRecent = FirstLocal;
3567   for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3568     auto *D = GetLocalDecl(*M, Record[N - I - 1]);
3569     ASTDeclReader::attachPreviousDecl(*this, D, MostRecent, CanonDecl);
3570     MostRecent = D;
3571   }
3572   ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
3573 }
3574 
3575 namespace {
3576   /// \brief Given an ObjC interface, goes through the modules and links to the
3577   /// interface all the categories for it.
3578   class ObjCCategoriesVisitor {
3579     ASTReader &Reader;
3580     serialization::GlobalDeclID InterfaceID;
3581     ObjCInterfaceDecl *Interface;
3582     llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
3583     unsigned PreviousGeneration;
3584     ObjCCategoryDecl *Tail;
3585     llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
3586 
add(ObjCCategoryDecl * Cat)3587     void add(ObjCCategoryDecl *Cat) {
3588       // Only process each category once.
3589       if (!Deserialized.erase(Cat))
3590         return;
3591 
3592       // Check for duplicate categories.
3593       if (Cat->getDeclName()) {
3594         ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
3595         if (Existing &&
3596             Reader.getOwningModuleFile(Existing)
3597                                           != Reader.getOwningModuleFile(Cat)) {
3598           // FIXME: We should not warn for duplicates in diamond:
3599           //
3600           //   MT     //
3601           //  /  \    //
3602           // ML  MR   //
3603           //  \  /    //
3604           //   MB     //
3605           //
3606           // If there are duplicates in ML/MR, there will be warning when
3607           // creating MB *and* when importing MB. We should not warn when
3608           // importing.
3609           Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
3610             << Interface->getDeclName() << Cat->getDeclName();
3611           Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
3612         } else if (!Existing) {
3613           // Record this category.
3614           Existing = Cat;
3615         }
3616       }
3617 
3618       // Add this category to the end of the chain.
3619       if (Tail)
3620         ASTDeclReader::setNextObjCCategory(Tail, Cat);
3621       else
3622         Interface->setCategoryListRaw(Cat);
3623       Tail = Cat;
3624     }
3625 
3626   public:
ObjCCategoriesVisitor(ASTReader & Reader,serialization::GlobalDeclID InterfaceID,ObjCInterfaceDecl * Interface,llvm::SmallPtrSetImpl<ObjCCategoryDecl * > & Deserialized,unsigned PreviousGeneration)3627     ObjCCategoriesVisitor(ASTReader &Reader,
3628                           serialization::GlobalDeclID InterfaceID,
3629                           ObjCInterfaceDecl *Interface,
3630                         llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
3631                           unsigned PreviousGeneration)
3632       : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
3633         Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
3634         Tail(nullptr)
3635     {
3636       // Populate the name -> category map with the set of known categories.
3637       for (auto *Cat : Interface->known_categories()) {
3638         if (Cat->getDeclName())
3639           NameCategoryMap[Cat->getDeclName()] = Cat;
3640 
3641         // Keep track of the tail of the category list.
3642         Tail = Cat;
3643       }
3644     }
3645 
operator ()(ModuleFile & M)3646     bool operator()(ModuleFile &M) {
3647       // If we've loaded all of the category information we care about from
3648       // this module file, we're done.
3649       if (M.Generation <= PreviousGeneration)
3650         return true;
3651 
3652       // Map global ID of the definition down to the local ID used in this
3653       // module file. If there is no such mapping, we'll find nothing here
3654       // (or in any module it imports).
3655       DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
3656       if (!LocalID)
3657         return true;
3658 
3659       // Perform a binary search to find the local redeclarations for this
3660       // declaration (if any).
3661       const ObjCCategoriesInfo Compare = { LocalID, 0 };
3662       const ObjCCategoriesInfo *Result
3663         = std::lower_bound(M.ObjCCategoriesMap,
3664                            M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
3665                            Compare);
3666       if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
3667           Result->DefinitionID != LocalID) {
3668         // We didn't find anything. If the class definition is in this module
3669         // file, then the module files it depends on cannot have any categories,
3670         // so suppress further lookup.
3671         return Reader.isDeclIDFromModule(InterfaceID, M);
3672       }
3673 
3674       // We found something. Dig out all of the categories.
3675       unsigned Offset = Result->Offset;
3676       unsigned N = M.ObjCCategories[Offset];
3677       M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
3678       for (unsigned I = 0; I != N; ++I)
3679         add(cast_or_null<ObjCCategoryDecl>(
3680               Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
3681       return true;
3682     }
3683   };
3684 } // end anonymous namespace
3685 
loadObjCCategories(serialization::GlobalDeclID ID,ObjCInterfaceDecl * D,unsigned PreviousGeneration)3686 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
3687                                    ObjCInterfaceDecl *D,
3688                                    unsigned PreviousGeneration) {
3689   ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
3690                                 PreviousGeneration);
3691   ModuleMgr.visit(Visitor);
3692 }
3693 
3694 template<typename DeclT, typename Fn>
forAllLaterRedecls(DeclT * D,Fn F)3695 static void forAllLaterRedecls(DeclT *D, Fn F) {
3696   F(D);
3697 
3698   // Check whether we've already merged D into its redeclaration chain.
3699   // MostRecent may or may not be nullptr if D has not been merged. If
3700   // not, walk the merged redecl chain and see if it's there.
3701   auto *MostRecent = D->getMostRecentDecl();
3702   bool Found = false;
3703   for (auto *Redecl = MostRecent; Redecl && !Found;
3704        Redecl = Redecl->getPreviousDecl())
3705     Found = (Redecl == D);
3706 
3707   // If this declaration is merged, apply the functor to all later decls.
3708   if (Found) {
3709     for (auto *Redecl = MostRecent; Redecl != D;
3710          Redecl = Redecl->getPreviousDecl())
3711       F(Redecl);
3712   }
3713 }
3714 
UpdateDecl(Decl * D,ModuleFile & ModuleFile,const RecordData & Record)3715 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
3716                                const RecordData &Record) {
3717   while (Idx < Record.size()) {
3718     switch ((DeclUpdateKind)Record[Idx++]) {
3719     case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
3720       auto *RD = cast<CXXRecordDecl>(D);
3721       // FIXME: If we also have an update record for instantiating the
3722       // definition of D, we need that to happen before we get here.
3723       Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
3724       assert(MD && "couldn't read decl from update record");
3725       // FIXME: We should call addHiddenDecl instead, to add the member
3726       // to its DeclContext.
3727       RD->addedMember(MD);
3728       break;
3729     }
3730 
3731     case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
3732       // It will be added to the template's specializations set when loaded.
3733       (void)Reader.ReadDecl(ModuleFile, Record, Idx);
3734       break;
3735 
3736     case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
3737       NamespaceDecl *Anon
3738         = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
3739 
3740       // Each module has its own anonymous namespace, which is disjoint from
3741       // any other module's anonymous namespaces, so don't attach the anonymous
3742       // namespace at all.
3743       if (ModuleFile.Kind != MK_ImplicitModule &&
3744           ModuleFile.Kind != MK_ExplicitModule) {
3745         if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
3746           TU->setAnonymousNamespace(Anon);
3747         else
3748           cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
3749       }
3750       break;
3751     }
3752 
3753     case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
3754       cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
3755           Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3756       break;
3757 
3758     case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: {
3759       auto Param = cast<ParmVarDecl>(D);
3760 
3761       // We have to read the default argument regardless of whether we use it
3762       // so that hypothetical further update records aren't messed up.
3763       // TODO: Add a function to skip over the next expr record.
3764       auto DefaultArg = Reader.ReadExpr(F);
3765 
3766       // Only apply the update if the parameter still has an uninstantiated
3767       // default argument.
3768       if (Param->hasUninstantiatedDefaultArg())
3769         Param->setDefaultArg(DefaultArg);
3770       break;
3771     }
3772 
3773     case UPD_CXX_ADDED_FUNCTION_DEFINITION: {
3774       FunctionDecl *FD = cast<FunctionDecl>(D);
3775       if (Reader.PendingBodies[FD]) {
3776         // FIXME: Maybe check for ODR violations.
3777         // It's safe to stop now because this update record is always last.
3778         return;
3779       }
3780 
3781       if (Record[Idx++]) {
3782         // Maintain AST consistency: any later redeclarations of this function
3783         // are inline if this one is. (We might have merged another declaration
3784         // into this one.)
3785         forAllLaterRedecls(FD, [](FunctionDecl *FD) {
3786           FD->setImplicitlyInline();
3787         });
3788       }
3789       FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3790       if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
3791         CD->NumCtorInitializers = Record[Idx++];
3792         if (CD->NumCtorInitializers)
3793           CD->CtorInitializers = ReadGlobalOffset(F, Record, Idx);
3794       }
3795       // Store the offset of the body so we can lazily load it later.
3796       Reader.PendingBodies[FD] = GetCurrentCursorOffset();
3797       HasPendingBody = true;
3798       assert(Idx == Record.size() && "lazy body must be last");
3799       break;
3800     }
3801 
3802     case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
3803       auto *RD = cast<CXXRecordDecl>(D);
3804       auto *OldDD = RD->getCanonicalDecl()->DefinitionData;
3805       bool HadRealDefinition =
3806           OldDD && (OldDD->Definition != RD ||
3807                     !Reader.PendingFakeDefinitionData.count(OldDD));
3808       ReadCXXRecordDefinition(RD, /*Update*/true);
3809 
3810       // Visible update is handled separately.
3811       uint64_t LexicalOffset = ReadLocalOffset(Record, Idx);
3812       if (!HadRealDefinition && LexicalOffset) {
3813         Reader.ReadLexicalDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
3814                                              LexicalOffset, RD);
3815         Reader.PendingFakeDefinitionData.erase(OldDD);
3816       }
3817 
3818       auto TSK = (TemplateSpecializationKind)Record[Idx++];
3819       SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
3820       if (MemberSpecializationInfo *MSInfo =
3821               RD->getMemberSpecializationInfo()) {
3822         MSInfo->setTemplateSpecializationKind(TSK);
3823         MSInfo->setPointOfInstantiation(POI);
3824       } else {
3825         ClassTemplateSpecializationDecl *Spec =
3826             cast<ClassTemplateSpecializationDecl>(RD);
3827         Spec->setTemplateSpecializationKind(TSK);
3828         Spec->setPointOfInstantiation(POI);
3829 
3830         if (Record[Idx++]) {
3831           auto PartialSpec =
3832               ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx);
3833           SmallVector<TemplateArgument, 8> TemplArgs;
3834           Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
3835           auto *TemplArgList = TemplateArgumentList::CreateCopy(
3836               Reader.getContext(), TemplArgs);
3837 
3838           // FIXME: If we already have a partial specialization set,
3839           // check that it matches.
3840           if (!Spec->getSpecializedTemplateOrPartial()
3841                    .is<ClassTemplatePartialSpecializationDecl *>())
3842             Spec->setInstantiationOf(PartialSpec, TemplArgList);
3843         }
3844       }
3845 
3846       RD->setTagKind((TagTypeKind)Record[Idx++]);
3847       RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3848       RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3849       RD->setRBraceLoc(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3850 
3851       if (Record[Idx++]) {
3852         AttrVec Attrs;
3853         Reader.ReadAttributes(F, Attrs, Record, Idx);
3854         D->setAttrsImpl(Attrs, Reader.getContext());
3855       }
3856       break;
3857     }
3858 
3859     case UPD_CXX_RESOLVED_DTOR_DELETE: {
3860       // Set the 'operator delete' directly to avoid emitting another update
3861       // record.
3862       auto *Del = Reader.ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
3863       auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());
3864       // FIXME: Check consistency if we have an old and new operator delete.
3865       if (!First->OperatorDelete)
3866         First->OperatorDelete = Del;
3867       break;
3868     }
3869 
3870     case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
3871       FunctionProtoType::ExceptionSpecInfo ESI;
3872       SmallVector<QualType, 8> ExceptionStorage;
3873       Reader.readExceptionSpec(ModuleFile, ExceptionStorage, ESI, Record, Idx);
3874 
3875       // Update this declaration's exception specification, if needed.
3876       auto *FD = cast<FunctionDecl>(D);
3877       auto *FPT = FD->getType()->castAs<FunctionProtoType>();
3878       // FIXME: If the exception specification is already present, check that it
3879       // matches.
3880       if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
3881         FD->setType(Reader.Context.getFunctionType(
3882             FPT->getReturnType(), FPT->getParamTypes(),
3883             FPT->getExtProtoInfo().withExceptionSpec(ESI)));
3884 
3885         // When we get to the end of deserializing, see if there are other decls
3886         // that we need to propagate this exception specification onto.
3887         Reader.PendingExceptionSpecUpdates.insert(
3888             std::make_pair(FD->getCanonicalDecl(), FD));
3889       }
3890       break;
3891     }
3892 
3893     case UPD_CXX_DEDUCED_RETURN_TYPE: {
3894       // FIXME: Also do this when merging redecls.
3895       QualType DeducedResultType = Reader.readType(ModuleFile, Record, Idx);
3896       for (auto *Redecl : merged_redecls(D)) {
3897         // FIXME: If the return type is already deduced, check that it matches.
3898         FunctionDecl *FD = cast<FunctionDecl>(Redecl);
3899         Reader.Context.adjustDeducedFunctionResultType(FD, DeducedResultType);
3900       }
3901       break;
3902     }
3903 
3904     case UPD_DECL_MARKED_USED: {
3905       // FIXME: This doesn't send the right notifications if there are
3906       // ASTMutationListeners other than an ASTWriter.
3907 
3908       // Maintain AST consistency: any later redeclarations are used too.
3909       D->setIsUsed();
3910       break;
3911     }
3912 
3913     case UPD_MANGLING_NUMBER:
3914       Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
3915       break;
3916 
3917     case UPD_STATIC_LOCAL_NUMBER:
3918       Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
3919       break;
3920 
3921     case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
3922       D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
3923           Reader.Context, ReadSourceRange(Record, Idx)));
3924       break;
3925 
3926     case UPD_DECL_EXPORTED: {
3927       unsigned SubmoduleID = readSubmoduleID(Record, Idx);
3928       auto *Exported = cast<NamedDecl>(D);
3929       if (auto *TD = dyn_cast<TagDecl>(Exported))
3930         Exported = TD->getDefinition();
3931       Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
3932       if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
3933         // FIXME: This doesn't send the right notifications if there are
3934         // ASTMutationListeners other than an ASTWriter.
3935         Reader.getContext().mergeDefinitionIntoModule(
3936             cast<NamedDecl>(Exported), Owner,
3937             /*NotifyListeners*/ false);
3938         Reader.PendingMergedDefinitionsToDeduplicate.insert(
3939             cast<NamedDecl>(Exported));
3940       } else if (Owner && Owner->NameVisibility != Module::AllVisible) {
3941         // If Owner is made visible at some later point, make this declaration
3942         // visible too.
3943         Reader.HiddenNamesMap[Owner].push_back(Exported);
3944       } else {
3945         // The declaration is now visible.
3946         Exported->Hidden = false;
3947       }
3948       break;
3949     }
3950 
3951     case UPD_DECL_MARKED_OPENMP_DECLARETARGET:
3952     case UPD_ADDED_ATTR_TO_RECORD:
3953       AttrVec Attrs;
3954       Reader.ReadAttributes(F, Attrs, Record, Idx);
3955       assert(Attrs.size() == 1);
3956       D->addAttr(Attrs[0]);
3957       break;
3958     }
3959   }
3960 }
3961