1//===- ASTReaderDecl.cpp - Decl Deserialization ---------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the ASTReader::readDeclRecord method, which is the
10// entrypoint for loading a decl.
11//
12//===----------------------------------------------------------------------===//
13
14#include "../AST/ByteCode/Context.h"
15#include "ASTCommon.h"
16#include "ASTReaderInternals.h"
17#include "clang/AST/ASTConcept.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/ASTStructuralEquivalence.h"
20#include "clang/AST/Attr.h"
21#include "clang/AST/AttrIterator.h"
22#include "clang/AST/Decl.h"
23#include "clang/AST/DeclBase.h"
24#include "clang/AST/DeclCXX.h"
25#include "clang/AST/DeclFriend.h"
26#include "clang/AST/DeclObjC.h"
27#include "clang/AST/DeclOpenMP.h"
28#include "clang/AST/DeclTemplate.h"
29#include "clang/AST/DeclVisitor.h"
30#include "clang/AST/DeclarationName.h"
31#include "clang/AST/Expr.h"
32#include "clang/AST/ExternalASTSource.h"
33#include "clang/AST/LambdaCapture.h"
34#include "clang/AST/NestedNameSpecifier.h"
35#include "clang/AST/OpenMPClause.h"
36#include "clang/AST/Redeclarable.h"
37#include "clang/AST/Stmt.h"
38#include "clang/AST/TemplateBase.h"
39#include "clang/AST/Type.h"
40#include "clang/AST/UnresolvedSet.h"
41#include "clang/Basic/AttrKinds.h"
42#include "clang/Basic/DiagnosticSema.h"
43#include "clang/Basic/ExceptionSpecificationType.h"
44#include "clang/Basic/IdentifierTable.h"
45#include "clang/Basic/LLVM.h"
46#include "clang/Basic/Lambda.h"
47#include "clang/Basic/LangOptions.h"
48#include "clang/Basic/Linkage.h"
49#include "clang/Basic/Module.h"
50#include "clang/Basic/PragmaKinds.h"
51#include "clang/Basic/SourceLocation.h"
52#include "clang/Basic/Specifiers.h"
53#include "clang/Sema/IdentifierResolver.h"
54#include "clang/Serialization/ASTBitCodes.h"
55#include "clang/Serialization/ASTRecordReader.h"
56#include "clang/Serialization/ContinuousRangeMap.h"
57#include "clang/Serialization/ModuleFile.h"
58#include "llvm/ADT/DenseMap.h"
59#include "llvm/ADT/FoldingSet.h"
60#include "llvm/ADT/SmallPtrSet.h"
61#include "llvm/ADT/SmallVector.h"
62#include "llvm/ADT/iterator_range.h"
63#include "llvm/Bitstream/BitstreamReader.h"
64#include "llvm/Support/ErrorHandling.h"
65#include "llvm/Support/SaveAndRestore.h"
66#include <algorithm>
67#include <cassert>
68#include <cstdint>
69#include <cstring>
70#include <string>
71#include <utility>
72
73using namespace clang;
74using namespace serialization;
75
76//===----------------------------------------------------------------------===//
77// Declaration Merging
78//===----------------------------------------------------------------------===//
79
80namespace {
81/// Results from loading a RedeclarableDecl.
82class RedeclarableResult {
83 Decl *MergeWith;
84 GlobalDeclID FirstID;
85 bool IsKeyDecl;
86
87public:
88 RedeclarableResult(Decl *MergeWith, GlobalDeclID FirstID, bool IsKeyDecl)
89 : MergeWith(MergeWith), FirstID(FirstID), IsKeyDecl(IsKeyDecl) {}
90
91 /// Retrieve the first ID.
92 GlobalDeclID getFirstID() const { return FirstID; }
93
94 /// Is this declaration a key declaration?
95 bool isKeyDecl() const { return IsKeyDecl; }
96
97 /// Get a known declaration that this should be merged with, if
98 /// any.
99 Decl *getKnownMergeTarget() const { return MergeWith; }
100};
101} // namespace
102
103namespace clang {
104class ASTDeclMerger {
105 ASTReader &Reader;
106
107public:
108 ASTDeclMerger(ASTReader &Reader) : Reader(Reader) {}
109
110 void mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl, Decl &Context,
111 unsigned Number);
112
113 /// \param KeyDeclID the decl ID of the key declaration \param D.
114 /// GlobalDeclID() if \param is not a key declaration.
115 /// See the comments of ASTReader::KeyDecls for the explanation
116 /// of key declaration.
117 template <typename T>
118 void mergeRedeclarableImpl(Redeclarable<T> *D, T *Existing,
119 GlobalDeclID KeyDeclID);
120
121 template <typename T>
122 void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
123 RedeclarableResult &Redecl) {
124 mergeRedeclarableImpl(
125 D, Existing, Redecl.isKeyDecl() ? Redecl.getFirstID() : GlobalDeclID());
126 }
127
128 void mergeTemplatePattern(RedeclarableTemplateDecl *D,
129 RedeclarableTemplateDecl *Existing, bool IsKeyDecl);
130
131 void MergeDefinitionData(CXXRecordDecl *D,
132 struct CXXRecordDecl::DefinitionData &&NewDD);
133 void MergeDefinitionData(ObjCInterfaceDecl *D,
134 struct ObjCInterfaceDecl::DefinitionData &&NewDD);
135 void MergeDefinitionData(ObjCProtocolDecl *D,
136 struct ObjCProtocolDecl::DefinitionData &&NewDD);
137};
138} // namespace clang
139
140//===----------------------------------------------------------------------===//
141// Declaration deserialization
142//===----------------------------------------------------------------------===//
143
144namespace clang {
145class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
146 ASTReader &Reader;
147 ASTDeclMerger MergeImpl;
148 ASTRecordReader &Record;
149 ASTReader::RecordLocation Loc;
150 const GlobalDeclID ThisDeclID;
151 const SourceLocation ThisDeclLoc;
152
153 using RecordData = ASTReader::RecordData;
154
155 TypeID DeferredTypeID = 0;
156 unsigned AnonymousDeclNumber = 0;
157 GlobalDeclID NamedDeclForTagDecl = GlobalDeclID();
158 IdentifierInfo *TypedefNameForLinkage = nullptr;
159
160 /// A flag to carry the information for a decl from the entity is
161 /// used. We use it to delay the marking of the canonical decl as used until
162 /// the entire declaration is deserialized and merged.
163 bool IsDeclMarkedUsed = false;
164
165 uint64_t GetCurrentCursorOffset();
166
167 uint64_t ReadLocalOffset() {
168 uint64_t LocalOffset = Record.readInt();
169 assert(LocalOffset < Loc.Offset && "offset point after current record");
170 return LocalOffset ? Loc.Offset - LocalOffset : 0;
171 }
172
173 uint64_t ReadGlobalOffset() {
174 uint64_t Local = ReadLocalOffset();
175 return Local ? Record.getGlobalBitOffset(LocalOffset: Local) : 0;
176 }
177
178 SourceLocation readSourceLocation() { return Record.readSourceLocation(); }
179
180 SourceRange readSourceRange() { return Record.readSourceRange(); }
181
182 TypeSourceInfo *readTypeSourceInfo() { return Record.readTypeSourceInfo(); }
183
184 GlobalDeclID readDeclID() { return Record.readDeclID(); }
185
186 std::string readString() { return Record.readString(); }
187
188 Decl *readDecl() { return Record.readDecl(); }
189
190 template <typename T> T *readDeclAs() { return Record.readDeclAs<T>(); }
191
192 serialization::SubmoduleID readSubmoduleID() {
193 if (Record.getIdx() == Record.size())
194 return 0;
195
196 return Record.getGlobalSubmoduleID(LocalID: Record.readInt());
197 }
198
199 Module *readModule() { return Record.getSubmodule(GlobalID: readSubmoduleID()); }
200
201 void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,
202 Decl *LambdaContext = nullptr,
203 unsigned IndexInLambdaContext = 0);
204 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
205 const CXXRecordDecl *D, Decl *LambdaContext,
206 unsigned IndexInLambdaContext);
207 void ReadObjCDefinitionData(struct ObjCInterfaceDecl::DefinitionData &Data);
208 void ReadObjCDefinitionData(struct ObjCProtocolDecl::DefinitionData &Data);
209
210 static DeclContext *getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC);
211
212 static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
213 DeclContext *DC, unsigned Index);
214 static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
215 unsigned Index, NamedDecl *D);
216
217 /// Commit to a primary definition of the class RD, which is known to be
218 /// a definition of the class. We might not have read the definition data
219 /// for it yet. If we haven't then allocate placeholder definition data
220 /// now too.
221 static CXXRecordDecl *getOrFakePrimaryClassDefinition(ASTReader &Reader,
222 CXXRecordDecl *RD);
223
224 /// Class used to capture the result of searching for an existing
225 /// declaration of a specific kind and name, along with the ability
226 /// to update the place where this result was found (the declaration
227 /// chain hanging off an identifier or the DeclContext we searched in)
228 /// if requested.
229 class FindExistingResult {
230 ASTReader &Reader;
231 NamedDecl *New = nullptr;
232 NamedDecl *Existing = nullptr;
233 bool AddResult = false;
234 unsigned AnonymousDeclNumber = 0;
235 IdentifierInfo *TypedefNameForLinkage = nullptr;
236
237 public:
238 FindExistingResult(ASTReader &Reader) : Reader(Reader) {}
239
240 FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,
241 unsigned AnonymousDeclNumber,
242 IdentifierInfo *TypedefNameForLinkage)
243 : Reader(Reader), New(New), Existing(Existing), AddResult(true),
244 AnonymousDeclNumber(AnonymousDeclNumber),
245 TypedefNameForLinkage(TypedefNameForLinkage) {}
246
247 FindExistingResult(FindExistingResult &&Other)
248 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
249 AddResult(Other.AddResult),
250 AnonymousDeclNumber(Other.AnonymousDeclNumber),
251 TypedefNameForLinkage(Other.TypedefNameForLinkage) {
252 Other.AddResult = false;
253 }
254
255 FindExistingResult &operator=(FindExistingResult &&) = delete;
256 ~FindExistingResult();
257
258 /// Suppress the addition of this result into the known set of
259 /// names.
260 void suppress() { AddResult = false; }
261
262 operator NamedDecl *() const { return Existing; }
263
264 template <typename T> operator T *() const {
265 return dyn_cast_or_null<T>(Existing);
266 }
267 };
268
269 static DeclContext *getPrimaryContextForMerging(ASTReader &Reader,
270 DeclContext *DC);
271 FindExistingResult findExisting(NamedDecl *D);
272
273public:
274 ASTDeclReader(ASTReader &Reader, ASTRecordReader &Record,
275 ASTReader::RecordLocation Loc, GlobalDeclID thisDeclID,
276 SourceLocation ThisDeclLoc)
277 : Reader(Reader), MergeImpl(Reader), Record(Record), Loc(Loc),
278 ThisDeclID(thisDeclID), ThisDeclLoc(ThisDeclLoc) {}
279
280 template <typename DeclT>
281 static Decl *getMostRecentDeclImpl(Redeclarable<DeclT> *D);
282 static Decl *getMostRecentDeclImpl(...);
283 static Decl *getMostRecentDecl(Decl *D);
284
285 template <typename DeclT>
286 static void attachPreviousDeclImpl(ASTReader &Reader, Redeclarable<DeclT> *D,
287 Decl *Previous, Decl *Canon);
288 static void attachPreviousDeclImpl(ASTReader &Reader, ...);
289 static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,
290 Decl *Canon);
291
292 static void checkMultipleDefinitionInNamedModules(ASTReader &Reader, Decl *D,
293 Decl *Previous);
294
295 template <typename DeclT>
296 static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
297 static void attachLatestDeclImpl(...);
298 static void attachLatestDecl(Decl *D, Decl *latest);
299
300 template <typename DeclT>
301 static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
302 static void markIncompleteDeclChainImpl(...);
303
304 void ReadSpecializations(ModuleFile &M, Decl *D,
305 llvm::BitstreamCursor &DeclsCursor, bool IsPartial);
306
307 void ReadFunctionDefinition(FunctionDecl *FD);
308 void Visit(Decl *D);
309
310 void UpdateDecl(Decl *D);
311
312 static void setNextObjCCategory(ObjCCategoryDecl *Cat,
313 ObjCCategoryDecl *Next) {
314 Cat->NextClassCategory = Next;
315 }
316
317 void VisitDecl(Decl *D);
318 void VisitPragmaCommentDecl(PragmaCommentDecl *D);
319 void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
320 void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
321 void VisitNamedDecl(NamedDecl *ND);
322 void VisitLabelDecl(LabelDecl *LD);
323 void VisitNamespaceDecl(NamespaceDecl *D);
324 void VisitHLSLBufferDecl(HLSLBufferDecl *D);
325 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
326 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
327 void VisitTypeDecl(TypeDecl *TD);
328 RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
329 void VisitTypedefDecl(TypedefDecl *TD);
330 void VisitTypeAliasDecl(TypeAliasDecl *TD);
331 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
332 void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
333 RedeclarableResult VisitTagDecl(TagDecl *TD);
334 void VisitEnumDecl(EnumDecl *ED);
335 RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
336 void VisitRecordDecl(RecordDecl *RD);
337 RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
338 void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
339 RedeclarableResult
340 VisitClassTemplateSpecializationDeclImpl(ClassTemplateSpecializationDecl *D);
341
342 void
343 VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) {
344 VisitClassTemplateSpecializationDeclImpl(D);
345 }
346
347 void VisitClassTemplatePartialSpecializationDecl(
348 ClassTemplatePartialSpecializationDecl *D);
349 RedeclarableResult
350 VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
351
352 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
353 VisitVarTemplateSpecializationDeclImpl(D);
354 }
355
356 void VisitVarTemplatePartialSpecializationDecl(
357 VarTemplatePartialSpecializationDecl *D);
358 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
359 void VisitValueDecl(ValueDecl *VD);
360 void VisitEnumConstantDecl(EnumConstantDecl *ECD);
361 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
362 void VisitDeclaratorDecl(DeclaratorDecl *DD);
363 void VisitFunctionDecl(FunctionDecl *FD);
364 void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *GD);
365 void VisitCXXMethodDecl(CXXMethodDecl *D);
366 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
367 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
368 void VisitCXXConversionDecl(CXXConversionDecl *D);
369 void VisitFieldDecl(FieldDecl *FD);
370 void VisitMSPropertyDecl(MSPropertyDecl *FD);
371 void VisitMSGuidDecl(MSGuidDecl *D);
372 void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D);
373 void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);
374 void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
375 RedeclarableResult VisitVarDeclImpl(VarDecl *D);
376 void ReadVarDeclInit(VarDecl *VD);
377 void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(D: VD); }
378 void VisitImplicitParamDecl(ImplicitParamDecl *PD);
379 void VisitParmVarDecl(ParmVarDecl *PD);
380 void VisitDecompositionDecl(DecompositionDecl *DD);
381 void VisitBindingDecl(BindingDecl *BD);
382 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
383 void VisitTemplateDecl(TemplateDecl *D);
384 void VisitConceptDecl(ConceptDecl *D);
385 void
386 VisitImplicitConceptSpecializationDecl(ImplicitConceptSpecializationDecl *D);
387 void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);
388 RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
389 void VisitClassTemplateDecl(ClassTemplateDecl *D);
390 void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
391 void VisitVarTemplateDecl(VarTemplateDecl *D);
392 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
393 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
394 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
395 void VisitUsingDecl(UsingDecl *D);
396 void VisitUsingEnumDecl(UsingEnumDecl *D);
397 void VisitUsingPackDecl(UsingPackDecl *D);
398 void VisitUsingShadowDecl(UsingShadowDecl *D);
399 void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
400 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
401 void VisitExportDecl(ExportDecl *D);
402 void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
403 void VisitTopLevelStmtDecl(TopLevelStmtDecl *D);
404 void VisitImportDecl(ImportDecl *D);
405 void VisitAccessSpecDecl(AccessSpecDecl *D);
406 void VisitFriendDecl(FriendDecl *D);
407 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
408 void VisitStaticAssertDecl(StaticAssertDecl *D);
409 void VisitExplicitInstantiationDecl(ExplicitInstantiationDecl *D);
410 void VisitCXXExpansionStmtDecl(CXXExpansionStmtDecl *D);
411 void VisitBlockDecl(BlockDecl *BD);
412 void VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D);
413 void VisitCapturedDecl(CapturedDecl *CD);
414 void VisitEmptyDecl(EmptyDecl *D);
415 void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
416
417 void VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D);
418 void VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D);
419
420 void VisitDeclContext(DeclContext *DC, LookupBlockOffsets &Offsets);
421
422 template <typename T>
423 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
424
425 template <typename T>
426 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
427
428 void mergeRedeclarableTemplate(RedeclarableTemplateDecl *D,
429 RedeclarableResult &Redecl);
430
431 template <typename T> void mergeMergeable(Mergeable<T> *D);
432
433 void mergeMergeable(LifetimeExtendedTemporaryDecl *D);
434
435 ObjCTypeParamList *ReadObjCTypeParamList();
436
437 // FIXME: Reorder according to DeclNodes.td?
438 void VisitObjCMethodDecl(ObjCMethodDecl *D);
439 void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
440 void VisitObjCContainerDecl(ObjCContainerDecl *D);
441 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
442 void VisitObjCIvarDecl(ObjCIvarDecl *D);
443 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
444 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
445 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
446 void VisitObjCImplDecl(ObjCImplDecl *D);
447 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
448 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
449 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
450 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
451 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
452 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
453 void VisitOMPAllocateDecl(OMPAllocateDecl *D);
454 void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
455 void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
456 void VisitOMPRequiresDecl(OMPRequiresDecl *D);
457 void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
458};
459} // namespace clang
460
461namespace {
462
463/// Iterator over the redeclarations of a declaration that have already
464/// been merged into the same redeclaration chain.
465template <typename DeclT> class MergedRedeclIterator {
466 DeclT *Start = nullptr;
467 DeclT *Canonical = nullptr;
468 DeclT *Current = nullptr;
469
470public:
471 MergedRedeclIterator() = default;
472 MergedRedeclIterator(DeclT *Start) : Start(Start), Current(Start) {}
473
474 DeclT *operator*() { return Current; }
475
476 MergedRedeclIterator &operator++() {
477 if (Current->isFirstDecl()) {
478 Canonical = Current;
479 Current = Current->getMostRecentDecl();
480 } else
481 Current = Current->getPreviousDecl();
482
483 // If we started in the merged portion, we'll reach our start position
484 // eventually. Otherwise, we'll never reach it, but the second declaration
485 // we reached was the canonical declaration, so stop when we see that one
486 // again.
487 if (Current == Start || Current == Canonical)
488 Current = nullptr;
489 return *this;
490 }
491
492 friend bool operator!=(const MergedRedeclIterator &A,
493 const MergedRedeclIterator &B) {
494 return A.Current != B.Current;
495 }
496};
497
498} // namespace
499
500template <typename DeclT>
501static llvm::iterator_range<MergedRedeclIterator<DeclT>>
502merged_redecls(DeclT *D) {
503 return llvm::make_range(MergedRedeclIterator<DeclT>(D),
504 MergedRedeclIterator<DeclT>());
505}
506
507uint64_t ASTDeclReader::GetCurrentCursorOffset() {
508 return Loc.F->DeclsCursor.GetCurrentBitNo() + Loc.F->GlobalBitOffset;
509}
510
511void ASTDeclReader::ReadFunctionDefinition(FunctionDecl *FD) {
512 if (Record.readInt()) {
513 Reader.DefinitionSource[FD] =
514 Loc.F->Kind == ModuleKind::MK_MainFile ||
515 Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;
516 }
517 if (auto *CD = dyn_cast<CXXConstructorDecl>(Val: FD)) {
518 CD->setNumCtorInitializers(Record.readInt());
519 if (CD->getNumCtorInitializers())
520 CD->CtorInitializers = ReadGlobalOffset();
521 }
522 // Store the offset of the body so we can lazily load it later.
523 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
524 // For now remember ThisDeclarationWasADefinition only for friend functions.
525 if (FD->getFriendObjectKind())
526 Reader.ThisDeclarationWasADefinitionSet.insert(V: FD);
527}
528
529void ASTDeclReader::Visit(Decl *D) {
530 DeclVisitor<ASTDeclReader, void>::Visit(D);
531
532 // At this point we have deserialized and merged the decl and it is safe to
533 // update its canonical decl to signal that the entire entity is used.
534 D->getCanonicalDecl()->Used |= IsDeclMarkedUsed;
535 IsDeclMarkedUsed = false;
536
537 if (auto *DD = dyn_cast<DeclaratorDecl>(Val: D)) {
538 if (auto *TInfo = DD->getTypeSourceInfo())
539 Record.readTypeLoc(TL: TInfo->getTypeLoc());
540 }
541
542 if (auto *TD = dyn_cast<TypeDecl>(Val: D)) {
543 // We have a fully initialized TypeDecl. Read its type now.
544 if (isa<TagDecl, TypedefDecl, TypeAliasDecl>(Val: TD))
545 assert(DeferredTypeID == 0 &&
546 "Deferred type not used for TagDecls and Typedefs");
547 else
548 TD->setTypeForDecl(Reader.GetType(ID: DeferredTypeID).getTypePtrOrNull());
549
550 // If this is a tag declaration with a typedef name for linkage, it's safe
551 // to load that typedef now.
552 if (NamedDeclForTagDecl.isValid())
553 cast<TagDecl>(Val: D)->TypedefNameDeclOrQualifier =
554 cast<TypedefNameDecl>(Val: Reader.GetDecl(ID: NamedDeclForTagDecl));
555 } else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(Val: D)) {
556 // if we have a fully initialized TypeDecl, we can safely read its type now.
557 ID->TypeForDecl = Reader.GetType(ID: DeferredTypeID).getTypePtrOrNull();
558 } else if (auto *FD = dyn_cast<FunctionDecl>(Val: D)) {
559 // FunctionDecl's body was written last after all other Stmts/Exprs.
560 if (Record.readInt())
561 ReadFunctionDefinition(FD);
562 } else if (auto *VD = dyn_cast<VarDecl>(Val: D)) {
563 ReadVarDeclInit(VD);
564 } else if (auto *FD = dyn_cast<FieldDecl>(Val: D)) {
565 if (FD->hasInClassInitializer() && Record.readInt()) {
566 FD->setLazyInClassInitializer(LazyDeclStmtPtr(GetCurrentCursorOffset()));
567 }
568 }
569}
570
571void ASTDeclReader::VisitDecl(Decl *D) {
572 BitsUnpacker DeclBits(Record.readInt());
573 auto ModuleOwnership =
574 (Decl::ModuleOwnershipKind)DeclBits.getNextBits(/*Width=*/3);
575 D->setReferenced(DeclBits.getNextBit());
576 D->Used = DeclBits.getNextBit();
577 IsDeclMarkedUsed |= D->Used;
578 D->setAccess((AccessSpecifier)DeclBits.getNextBits(/*Width=*/2));
579 D->setImplicit(DeclBits.getNextBit());
580 bool HasStandaloneLexicalDC = DeclBits.getNextBit();
581 bool HasAttrs = DeclBits.getNextBit();
582 D->setTopLevelDeclInObjCContainer(DeclBits.getNextBit());
583 D->InvalidDecl = DeclBits.getNextBit();
584 D->FromASTFile = true;
585
586 if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
587 isa<ParmVarDecl, ObjCTypeParamDecl>(Val: D)) {
588 // We don't want to deserialize the DeclContext of a template
589 // parameter or of a parameter of a function template immediately. These
590 // entities might be used in the formulation of its DeclContext (for
591 // example, a function parameter can be used in decltype() in trailing
592 // return type of the function). Use the translation unit DeclContext as a
593 // placeholder.
594 GlobalDeclID SemaDCIDForTemplateParmDecl = readDeclID();
595 GlobalDeclID LexicalDCIDForTemplateParmDecl =
596 HasStandaloneLexicalDC ? readDeclID() : GlobalDeclID();
597 if (LexicalDCIDForTemplateParmDecl.isInvalid())
598 LexicalDCIDForTemplateParmDecl = SemaDCIDForTemplateParmDecl;
599 Reader.addPendingDeclContextInfo(D,
600 SemaDC: SemaDCIDForTemplateParmDecl,
601 LexicalDC: LexicalDCIDForTemplateParmDecl);
602 D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
603 } else {
604 auto *SemaDC = readDeclAs<DeclContext>();
605 auto *LexicalDC =
606 HasStandaloneLexicalDC ? readDeclAs<DeclContext>() : nullptr;
607 if (!LexicalDC)
608 LexicalDC = SemaDC;
609 // If the context is a class, we might not have actually merged it yet, in
610 // the case where the definition comes from an update record.
611 DeclContext *MergedSemaDC;
612 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: SemaDC))
613 MergedSemaDC = getOrFakePrimaryClassDefinition(Reader, RD);
614 else
615 MergedSemaDC = Reader.MergedDeclContexts.lookup(Val: SemaDC);
616 // Avoid calling setLexicalDeclContext() directly because it uses
617 // Decl::getASTContext() internally which is unsafe during derialization.
618 D->setDeclContextsImpl(SemaDC: MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
619 Ctx&: Reader.getContext());
620 }
621 D->setLocation(ThisDeclLoc);
622
623 if (HasAttrs) {
624 AttrVec Attrs;
625 Record.readAttributes(Attrs);
626 // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
627 // internally which is unsafe during derialization.
628 D->setAttrsImpl(Attrs, Ctx&: Reader.getContext());
629 }
630
631 // Determine whether this declaration is part of a (sub)module. If so, it
632 // may not yet be visible.
633 bool ModulePrivate =
634 (ModuleOwnership == Decl::ModuleOwnershipKind::ModulePrivate);
635 if (unsigned SubmoduleID = readSubmoduleID()) {
636 switch (ModuleOwnership) {
637 case Decl::ModuleOwnershipKind::Visible:
638 ModuleOwnership = Decl::ModuleOwnershipKind::VisibleWhenImported;
639 break;
640 case Decl::ModuleOwnershipKind::Unowned:
641 case Decl::ModuleOwnershipKind::VisibleWhenImported:
642 case Decl::ModuleOwnershipKind::VisiblePromoted:
643 case Decl::ModuleOwnershipKind::ReachableWhenImported:
644 case Decl::ModuleOwnershipKind::ModulePrivate:
645 break;
646 }
647
648 D->setModuleOwnershipKind(ModuleOwnership);
649 // Store the owning submodule ID in the declaration.
650 D->setOwningModuleID(SubmoduleID);
651
652 if (ModulePrivate) {
653 // Module-private declarations are never visible, so there is no work to
654 // do.
655 } else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
656 // If local visibility is being tracked, this declaration will become
657 // hidden and visible as the owning module does.
658 } else if (Module *Owner = Reader.getSubmodule(GlobalID: SubmoduleID)) {
659 // Mark the declaration as visible when its owning module becomes visible.
660 if (Owner->NameVisibility == Module::AllVisible)
661 D->setVisibleDespiteOwningModule();
662 else
663 Reader.HiddenNamesMap[Owner].push_back(Elt: D);
664 }
665 } else if (ModulePrivate) {
666 D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
667 }
668}
669
670void ASTDeclReader::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
671 VisitDecl(D);
672 D->setLocation(readSourceLocation());
673 D->CommentKind = (PragmaMSCommentKind)Record.readInt();
674 std::string Arg = readString();
675 memcpy(dest: D->getTrailingObjects(), src: Arg.data(), n: Arg.size());
676 D->getTrailingObjects()[Arg.size()] = '\0';
677}
678
679void ASTDeclReader::VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) {
680 VisitDecl(D);
681 D->setLocation(readSourceLocation());
682 std::string Name = readString();
683 memcpy(dest: D->getTrailingObjects(), src: Name.data(), n: Name.size());
684 D->getTrailingObjects()[Name.size()] = '\0';
685
686 D->ValueStart = Name.size() + 1;
687 std::string Value = readString();
688 memcpy(dest: D->getTrailingObjects() + D->ValueStart, src: Value.data(), n: Value.size());
689 D->getTrailingObjects()[D->ValueStart + Value.size()] = '\0';
690}
691
692void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
693 llvm_unreachable("Translation units are not serialized");
694}
695
696void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
697 VisitDecl(D: ND);
698 ND->setDeclName(Record.readDeclarationName());
699 AnonymousDeclNumber = Record.readInt();
700}
701
702void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
703 VisitNamedDecl(ND: TD);
704 TD->setLocStart(readSourceLocation());
705 // Delay type reading until after we have fully initialized the decl.
706 if (!isa<TagDecl, TypedefDecl, TypeAliasDecl>(Val: TD))
707 DeferredTypeID = Record.getGlobalTypeID(LocalID: Record.readInt());
708}
709
710RedeclarableResult ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
711 RedeclarableResult Redecl = VisitRedeclarable(D: TD);
712 VisitTypeDecl(TD);
713 TypeSourceInfo *TInfo = readTypeSourceInfo();
714 if (Record.readInt()) { // isModed
715 QualType modedT = Record.readType();
716 TD->setModedTypeSourceInfo(unmodedTSI: TInfo, modedTy: modedT);
717 } else
718 TD->setTypeSourceInfo(TInfo);
719 // Read and discard the declaration for which this is a typedef name for
720 // linkage, if it exists. We cannot rely on our type to pull in this decl,
721 // because it might have been merged with a type from another module and
722 // thus might not refer to our version of the declaration.
723 readDecl();
724 return Redecl;
725}
726
727void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
728 RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
729 mergeRedeclarable(DBase: TD, Redecl);
730}
731
732void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
733 RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
734 if (auto *Template = readDeclAs<TypeAliasTemplateDecl>())
735 // Merged when we merge the template.
736 TD->setDescribedAliasTemplate(Template);
737 else
738 mergeRedeclarable(DBase: TD, Redecl);
739}
740
741RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
742 RedeclarableResult Redecl = VisitRedeclarable(D: TD);
743 VisitTypeDecl(TD);
744
745 TD->IdentifierNamespace = Record.readInt();
746
747 BitsUnpacker TagDeclBits(Record.readInt());
748 TD->setTagKind(
749 static_cast<TagTypeKind>(TagDeclBits.getNextBits(/*Width=*/3)));
750 TD->setCompleteDefinition(TagDeclBits.getNextBit());
751 TD->setEmbeddedInDeclarator(TagDeclBits.getNextBit());
752 TD->setFreeStanding(TagDeclBits.getNextBit());
753 TD->setCompleteDefinitionRequired(TagDeclBits.getNextBit());
754 TD->setBraceRange(readSourceRange());
755
756 switch (TagDeclBits.getNextBits(/*Width=*/2)) {
757 case 0:
758 break;
759 case 1: { // ExtInfo
760 auto *Info = new (Reader.getContext()) TagDecl::ExtInfo();
761 Record.readQualifierInfo(Info&: *Info);
762 TD->TypedefNameDeclOrQualifier = Info;
763 break;
764 }
765 case 2: // TypedefNameForAnonDecl
766 NamedDeclForTagDecl = readDeclID();
767 TypedefNameForLinkage = Record.readIdentifier();
768 break;
769 default:
770 llvm_unreachable("unexpected tag info kind");
771 }
772
773 if (!isa<CXXRecordDecl>(Val: TD))
774 mergeRedeclarable(DBase: TD, Redecl);
775 return Redecl;
776}
777
778void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
779 VisitTagDecl(TD: ED);
780 if (TypeSourceInfo *TI = readTypeSourceInfo())
781 ED->setIntegerTypeSourceInfo(TI);
782 else
783 ED->setIntegerType(Record.readType());
784 ED->setPromotionType(Record.readType());
785
786 BitsUnpacker EnumDeclBits(Record.readInt());
787 ED->setNumPositiveBits(EnumDeclBits.getNextBits(/*Width=*/8));
788 ED->setNumNegativeBits(EnumDeclBits.getNextBits(/*Width=*/8));
789 ED->setScoped(EnumDeclBits.getNextBit());
790 ED->setScopedUsingClassTag(EnumDeclBits.getNextBit());
791 ED->setFixed(EnumDeclBits.getNextBit());
792
793 ED->setHasODRHash(true);
794 ED->ODRHash = Record.readInt();
795
796 // If this is a definition subject to the ODR, and we already have a
797 // definition, merge this one into it.
798 if (ED->isCompleteDefinition() && Reader.getContext().getLangOpts().Modules) {
799 EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];
800 if (!OldDef) {
801 // This is the first time we've seen an imported definition. Look for a
802 // local definition before deciding that we are the first definition.
803 for (auto *D : merged_redecls(D: ED->getCanonicalDecl())) {
804 if (!D->isFromASTFile() && D->isCompleteDefinition()) {
805 OldDef = D;
806 break;
807 }
808 }
809 }
810 if (OldDef) {
811 Reader.MergedDeclContexts.insert(KV: std::make_pair(x&: ED, y&: OldDef));
812 ED->demoteThisDefinitionToDeclaration();
813 Reader.mergeDefinitionVisibility(Def: OldDef, MergedDef: ED);
814 // We don't want to check the ODR hash value for declarations from global
815 // module fragment.
816 if (!shouldSkipCheckingODR(D: ED) && !shouldSkipCheckingODR(D: OldDef) &&
817 OldDef->getODRHash() != ED->getODRHash())
818 Reader.PendingEnumOdrMergeFailures[OldDef].push_back(Elt: ED);
819 } else {
820 OldDef = ED;
821 }
822 }
823
824 if (auto *InstED = readDeclAs<EnumDecl>()) {
825 auto TSK = (TemplateSpecializationKind)Record.readInt();
826 SourceLocation POI = readSourceLocation();
827 ED->setInstantiationOfMemberEnum(C&: Reader.getContext(), ED: InstED, TSK);
828 ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
829 }
830}
831
832RedeclarableResult ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
833 RedeclarableResult Redecl = VisitTagDecl(TD: RD);
834
835 BitsUnpacker RecordDeclBits(Record.readInt());
836 RD->setHasFlexibleArrayMember(RecordDeclBits.getNextBit());
837 RD->setAnonymousStructOrUnion(RecordDeclBits.getNextBit());
838 RD->setHasObjectMember(RecordDeclBits.getNextBit());
839 RD->setHasVolatileMember(RecordDeclBits.getNextBit());
840 RD->setNonTrivialToPrimitiveDefaultInitialize(RecordDeclBits.getNextBit());
841 RD->setNonTrivialToPrimitiveCopy(RecordDeclBits.getNextBit());
842 RD->setNonTrivialToPrimitiveDestroy(RecordDeclBits.getNextBit());
843 RD->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(
844 RecordDeclBits.getNextBit());
845 RD->setHasNonTrivialToPrimitiveDestructCUnion(RecordDeclBits.getNextBit());
846 RD->setHasNonTrivialToPrimitiveCopyCUnion(RecordDeclBits.getNextBit());
847 RD->setHasUninitializedExplicitInitFields(RecordDeclBits.getNextBit());
848 RD->setParamDestroyedInCallee(RecordDeclBits.getNextBit());
849 RD->setArgPassingRestrictions(
850 (RecordArgPassingKind)RecordDeclBits.getNextBits(/*Width=*/2));
851 return Redecl;
852}
853
854void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
855 VisitRecordDeclImpl(RD);
856 RD->setODRHash(Record.readInt());
857
858 // Maintain the invariant of a redeclaration chain containing only
859 // a single definition.
860 if (RD->isCompleteDefinition()) {
861 RecordDecl *Canon = static_cast<RecordDecl *>(RD->getCanonicalDecl());
862 RecordDecl *&OldDef = Reader.RecordDefinitions[Canon];
863 if (!OldDef) {
864 // This is the first time we've seen an imported definition. Look for a
865 // local definition before deciding that we are the first definition.
866 for (auto *D : merged_redecls(D: Canon)) {
867 if (!D->isFromASTFile() && D->isCompleteDefinition()) {
868 OldDef = D;
869 break;
870 }
871 }
872 }
873 if (OldDef) {
874 Reader.MergedDeclContexts.insert(KV: std::make_pair(x&: RD, y&: OldDef));
875 RD->demoteThisDefinitionToDeclaration();
876 Reader.mergeDefinitionVisibility(Def: OldDef, MergedDef: RD);
877 if (OldDef->getODRHash() != RD->getODRHash())
878 Reader.PendingRecordOdrMergeFailures[OldDef].push_back(Elt: RD);
879 } else {
880 OldDef = RD;
881 }
882 }
883}
884
885void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
886 VisitNamedDecl(ND: VD);
887 // For function or variable declarations, defer reading the type in case the
888 // declaration has a deduced type that references an entity declared within
889 // the function definition or variable initializer.
890 if (isa<FunctionDecl, VarDecl>(Val: VD))
891 DeferredTypeID = Record.getGlobalTypeID(LocalID: Record.readInt());
892 else
893 VD->setType(Record.readType());
894}
895
896void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
897 VisitValueDecl(VD: ECD);
898 if (Record.readInt())
899 ECD->setInitExpr(Record.readExpr());
900 ECD->setInitVal(C: Reader.getContext(), V: Record.readAPSInt());
901 mergeMergeable(D: ECD);
902}
903
904void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
905 VisitValueDecl(VD: DD);
906 DD->setInnerLocStart(readSourceLocation());
907 if (Record.readInt()) { // hasExtInfo
908 auto *Info = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
909 Record.readQualifierInfo(Info&: *Info);
910 Info->TrailingRequiresClause = AssociatedConstraint(
911 Record.readExpr(),
912 UnsignedOrNone::fromInternalRepresentation(Rep: Record.readUInt32()));
913 DD->DeclInfo = Info;
914 }
915 QualType TSIType = Record.readType();
916 DD->setTypeSourceInfo(
917 TSIType.isNull() ? nullptr
918 : Reader.getContext().CreateTypeSourceInfo(T: TSIType));
919}
920
921void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
922 RedeclarableResult Redecl = VisitRedeclarable(D: FD);
923
924 FunctionDecl *Existing = nullptr;
925
926 switch ((FunctionDecl::TemplatedKind)Record.readInt()) {
927 case FunctionDecl::TK_NonTemplate:
928 break;
929 case FunctionDecl::TK_DependentNonTemplate:
930 FD->setInstantiatedFromDecl(readDeclAs<FunctionDecl>());
931 break;
932 case FunctionDecl::TK_FunctionTemplate: {
933 auto *Template = readDeclAs<FunctionTemplateDecl>();
934 Template->init(NewTemplatedDecl: FD);
935 FD->setDescribedFunctionTemplate(Template);
936 break;
937 }
938 case FunctionDecl::TK_MemberSpecialization: {
939 auto *InstFD = readDeclAs<FunctionDecl>();
940 auto TSK = (TemplateSpecializationKind)Record.readInt();
941 SourceLocation POI = readSourceLocation();
942 FD->setInstantiationOfMemberFunction(C&: Reader.getContext(), FD: InstFD, TSK);
943 FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
944 break;
945 }
946 case FunctionDecl::TK_FunctionTemplateSpecialization: {
947 auto *Template = readDeclAs<FunctionTemplateDecl>();
948 auto TSK = (TemplateSpecializationKind)Record.readInt();
949
950 // Template arguments.
951 SmallVector<TemplateArgument, 8> TemplArgs;
952 Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
953
954 // Template args as written.
955 TemplateArgumentListInfo TemplArgsWritten;
956 bool HasTemplateArgumentsAsWritten = Record.readBool();
957 if (HasTemplateArgumentsAsWritten)
958 Record.readTemplateArgumentListInfo(Result&: TemplArgsWritten);
959
960 SourceLocation POI = readSourceLocation();
961
962 ASTContext &C = Reader.getContext();
963 TemplateArgumentList *TemplArgList =
964 TemplateArgumentList::CreateCopy(Context&: C, Args: TemplArgs);
965
966 MemberSpecializationInfo *MSInfo = nullptr;
967 if (Record.readInt()) {
968 auto *FD = readDeclAs<FunctionDecl>();
969 auto TSK = (TemplateSpecializationKind)Record.readInt();
970 SourceLocation POI = readSourceLocation();
971
972 MSInfo = new (C) MemberSpecializationInfo(FD, TSK);
973 MSInfo->setPointOfInstantiation(POI);
974 }
975
976 FunctionTemplateSpecializationInfo *FTInfo =
977 FunctionTemplateSpecializationInfo::Create(
978 C, FD, Template, TSK, TemplateArgs: TemplArgList,
979 TemplateArgsAsWritten: HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr, POI,
980 MSInfo);
981 FD->TemplateOrSpecialization = FTInfo;
982
983 if (FD->isCanonicalDecl()) { // if canonical add to template's set.
984 // The template that contains the specializations set. It's not safe to
985 // use getCanonicalDecl on Template since it may still be initializing.
986 auto *CanonTemplate = readDeclAs<FunctionTemplateDecl>();
987 // Get the insert token by lookup() instead of calling insert(FTInfo)
988 // directly to avoid the getASTContext() call in
989 // FunctionTemplateSpecializationInfo's Profile().
990 // We avoid getASTContext because a decl in the parent hierarchy may
991 // be initializing.
992 llvm::FoldingSetNodeID ID;
993 FunctionTemplateSpecializationInfo::Profile(ID, TemplateArgs: TemplArgs, Context: C);
994 llvm::FoldingSetInsertToken InsertToken;
995 FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
996 FunctionTemplateSpecializationInfo *ExistingInfo =
997 CommonPtr->Specializations.lookup(ID, Token&: InsertToken);
998 if (InsertToken)
999 CommonPtr->Specializations.insert(N: FTInfo, Token: InsertToken);
1000 else {
1001 Existing = ExistingInfo->getFunction();
1002 }
1003 }
1004 break;
1005 }
1006 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
1007 // Templates.
1008 UnresolvedSet<8> Candidates;
1009 unsigned NumCandidates = Record.readInt();
1010 while (NumCandidates--)
1011 Candidates.addDecl(D: readDeclAs<NamedDecl>());
1012
1013 // Templates args.
1014 TemplateArgumentListInfo TemplArgsWritten;
1015 bool HasTemplateArgumentsAsWritten = Record.readBool();
1016 if (HasTemplateArgumentsAsWritten)
1017 Record.readTemplateArgumentListInfo(Result&: TemplArgsWritten);
1018
1019 FD->setDependentTemplateSpecialization(
1020 Context&: Reader.getContext(), Templates: Candidates,
1021 TemplateArgs: HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr);
1022 // These are not merged; we don't need to merge redeclarations of dependent
1023 // template friends.
1024 break;
1025 }
1026 }
1027
1028 VisitDeclaratorDecl(DD: FD);
1029
1030 // Attach a type to this function. Use the real type if possible, but fall
1031 // back to the type as written if it involves a deduced return type.
1032 if (FD->getTypeSourceInfo() && FD->getTypeSourceInfo()
1033 ->getType()
1034 ->castAs<FunctionType>()
1035 ->getReturnType()
1036 ->getContainedAutoType()) {
1037 // We'll set up the real type in Visit, once we've finished loading the
1038 // function.
1039 FD->setType(FD->getTypeSourceInfo()->getType());
1040 Reader.PendingDeducedFunctionTypes.push_back(Elt: {FD, DeferredTypeID});
1041 } else {
1042 FD->setType(Reader.GetType(ID: DeferredTypeID));
1043 }
1044 DeferredTypeID = 0;
1045
1046 FD->DNLoc = Record.readDeclarationNameLoc(Name: FD->getDeclName());
1047 FD->IdentifierNamespace = Record.readInt();
1048
1049 // FunctionDecl's body is handled last at ASTDeclReader::Visit,
1050 // after everything else is read.
1051 BitsUnpacker FunctionDeclBits(Record.readInt());
1052
1053 FD->setCachedLinkage((Linkage)FunctionDeclBits.getNextBits(/*Width=*/3));
1054 FD->setStorageClass((StorageClass)FunctionDeclBits.getNextBits(/*Width=*/3));
1055 FD->setInlineSpecified(FunctionDeclBits.getNextBit());
1056 FD->setImplicitlyInline(FunctionDeclBits.getNextBit());
1057 FD->setHasSkippedBody(FunctionDeclBits.getNextBit());
1058 FD->setVirtualAsWritten(FunctionDeclBits.getNextBit());
1059 // We defer calling `FunctionDecl::setPure()` here as for methods of
1060 // `CXXTemplateSpecializationDecl`s, we may not have connected up the
1061 // definition (which is required for `setPure`).
1062 const bool Pure = FunctionDeclBits.getNextBit();
1063 FD->setHasInheritedPrototype(FunctionDeclBits.getNextBit());
1064 FD->setHasWrittenPrototype(FunctionDeclBits.getNextBit());
1065 FD->setDeletedAsWritten(D: FunctionDeclBits.getNextBit());
1066 FD->setTrivial(FunctionDeclBits.getNextBit());
1067 FD->setTrivialForCall(FunctionDeclBits.getNextBit());
1068 FD->setDefaulted(FunctionDeclBits.getNextBit());
1069 FD->setExplicitlyDefaulted(FunctionDeclBits.getNextBit());
1070 FD->setIneligibleOrNotSelected(FunctionDeclBits.getNextBit());
1071 FD->setConstexprKind(
1072 (ConstexprSpecKind)FunctionDeclBits.getNextBits(/*Width=*/2));
1073 FD->setHasImplicitReturnZero(FunctionDeclBits.getNextBit());
1074 FD->setIsMultiVersion(FunctionDeclBits.getNextBit());
1075 FD->setLateTemplateParsed(FunctionDeclBits.getNextBit());
1076 FD->setInstantiatedFromMemberTemplate(FunctionDeclBits.getNextBit());
1077 FD->setFriendConstraintRefersToEnclosingTemplate(
1078 FunctionDeclBits.getNextBit());
1079 FD->setUsesSEHTry(FunctionDeclBits.getNextBit());
1080 FD->setIsDestroyingOperatorDelete(FunctionDeclBits.getNextBit());
1081 FD->setIsTypeAwareOperatorNewOrDelete(FunctionDeclBits.getNextBit());
1082
1083 FD->EndRangeLoc = readSourceLocation();
1084 if (FD->isExplicitlyDefaulted())
1085 FD->setDefaultLoc(readSourceLocation());
1086
1087 FD->ODRHash = Record.readInt();
1088 FD->setHasODRHash(true);
1089
1090 if (FD->isDefaulted() || FD->isDeletedAsWritten()) {
1091 // If 'Info' is nonzero, we need to read an DefaultedOrDeletedInfo; if,
1092 // additionally, the second bit is also set, we also need to read
1093 // a DeletedMessage for the DefaultedOrDeletedInfo.
1094 if (auto Info = Record.readInt()) {
1095 bool HasMessage = Info & 2;
1096 StringLiteral *DeletedMessage =
1097 HasMessage ? cast<StringLiteral>(Val: Record.readExpr()) : nullptr;
1098
1099 FPOptionsOverride FPFeatures =
1100 FPOptionsOverride::getFromOpaqueInt(I: Record.readInt());
1101
1102 unsigned NumLookups = Record.readInt();
1103 SmallVector<DeclAccessPair, 8> Lookups;
1104 for (unsigned I = 0; I != NumLookups; ++I) {
1105 NamedDecl *ND = Record.readDeclAs<NamedDecl>();
1106 AccessSpecifier AS = (AccessSpecifier)Record.readInt();
1107 Lookups.push_back(Elt: DeclAccessPair::make(D: ND, AS));
1108 }
1109
1110 FD->setDefaultedOrDeletedInfo(
1111 FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
1112 Context&: Reader.getContext(), Lookups, FPFeatures, DeletedMessage));
1113 }
1114 }
1115
1116 if (Existing)
1117 MergeImpl.mergeRedeclarable(D: FD, Existing, Redecl);
1118 else if (auto Kind = FD->getTemplatedKind();
1119 Kind == FunctionDecl::TK_FunctionTemplate ||
1120 Kind == FunctionDecl::TK_FunctionTemplateSpecialization) {
1121 // Function Templates have their FunctionTemplateDecls merged instead of
1122 // their FunctionDecls.
1123 auto merge = [this, &Redecl, FD](auto &&F) {
1124 auto *Existing = cast_or_null<FunctionDecl>(Val: Redecl.getKnownMergeTarget());
1125 RedeclarableResult NewRedecl(Existing ? F(Existing) : nullptr,
1126 Redecl.getFirstID(), Redecl.isKeyDecl());
1127 mergeRedeclarableTemplate(D: F(FD), Redecl&: NewRedecl);
1128 };
1129 if (Kind == FunctionDecl::TK_FunctionTemplate)
1130 merge(
1131 [](FunctionDecl *FD) { return FD->getDescribedFunctionTemplate(); });
1132 else
1133 merge([](FunctionDecl *FD) {
1134 return FD->getTemplateSpecializationInfo()->getTemplate();
1135 });
1136 } else
1137 mergeRedeclarable(DBase: FD, Redecl);
1138
1139 // Defer calling `setPure` until merging above has guaranteed we've set
1140 // `DefinitionData` (as this will need to access it).
1141 FD->setIsPureVirtual(Pure);
1142
1143 // Read in the parameters.
1144 unsigned NumParams = Record.readInt();
1145 SmallVector<ParmVarDecl *, 16> Params;
1146 Params.reserve(N: NumParams);
1147 for (unsigned I = 0; I != NumParams; ++I)
1148 Params.push_back(Elt: readDeclAs<ParmVarDecl>());
1149 FD->setParams(C&: Reader.getContext(), NewParamInfo: Params);
1150
1151 // If the declaration is a SYCL kernel entry point function as indicated by
1152 // the presence of a sycl_kernel_entry_point attribute, register it so that
1153 // associated metadata is recreated.
1154 if (FD->hasAttr<SYCLKernelEntryPointAttr>()) {
1155 auto *SKEPAttr = FD->getAttr<SYCLKernelEntryPointAttr>();
1156 ASTContext &C = Reader.getContext();
1157 const SYCLKernelInfo *SKI = C.findSYCLKernelInfo(T: SKEPAttr->getKernelName());
1158 if (SKI) {
1159 if (!declaresSameEntity(D1: FD, D2: SKI->getKernelEntryPointDecl())) {
1160 Reader.Diag(Loc: FD->getLocation(), DiagID: diag::err_sycl_kernel_name_conflict)
1161 << SKEPAttr;
1162 Reader.Diag(Loc: SKI->getKernelEntryPointDecl()->getLocation(),
1163 DiagID: diag::note_previous_declaration);
1164 SKEPAttr->setInvalidAttr();
1165 }
1166 } else {
1167 C.registerSYCLEntryPointFunction(FD);
1168 }
1169 }
1170}
1171
1172void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
1173 VisitNamedDecl(ND: MD);
1174 if (Record.readInt()) {
1175 // Load the body on-demand. Most clients won't care, because method
1176 // definitions rarely show up in headers.
1177 Reader.PendingBodies[MD] = GetCurrentCursorOffset();
1178 }
1179 MD->setSelfDecl(readDeclAs<ImplicitParamDecl>());
1180 MD->setCmdDecl(readDeclAs<ImplicitParamDecl>());
1181 MD->setInstanceMethod(Record.readInt());
1182 MD->setVariadic(Record.readInt());
1183 MD->setPropertyAccessor(Record.readInt());
1184 MD->setSynthesizedAccessorStub(Record.readInt());
1185 MD->setDefined(Record.readInt());
1186 MD->setOverriding(Record.readInt());
1187 MD->setHasSkippedBody(Record.readInt());
1188
1189 MD->setIsRedeclaration(Record.readInt());
1190 MD->setHasRedeclaration(Record.readInt());
1191 if (MD->hasRedeclaration())
1192 Reader.getContext().setObjCMethodRedeclaration(MD,
1193 Redecl: readDeclAs<ObjCMethodDecl>());
1194
1195 MD->setDeclImplementation(
1196 static_cast<ObjCImplementationControl>(Record.readInt()));
1197 MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record.readInt());
1198 MD->setRelatedResultType(Record.readInt());
1199 MD->setReturnType(Record.readType());
1200 MD->setReturnTypeSourceInfo(readTypeSourceInfo());
1201 MD->DeclEndLoc = readSourceLocation();
1202 unsigned NumParams = Record.readInt();
1203 SmallVector<ParmVarDecl *, 16> Params;
1204 Params.reserve(N: NumParams);
1205 for (unsigned I = 0; I != NumParams; ++I)
1206 Params.push_back(Elt: readDeclAs<ParmVarDecl>());
1207
1208 MD->setSelLocsKind((SelectorLocationsKind)Record.readInt());
1209 unsigned NumStoredSelLocs = Record.readInt();
1210 SmallVector<SourceLocation, 16> SelLocs;
1211 SelLocs.reserve(N: NumStoredSelLocs);
1212 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
1213 SelLocs.push_back(Elt: readSourceLocation());
1214
1215 MD->setParamsAndSelLocs(C&: Reader.getContext(), Params, SelLocs);
1216}
1217
1218void ASTDeclReader::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
1219 VisitTypedefNameDecl(TD: D);
1220
1221 D->Variance = Record.readInt();
1222 D->Index = Record.readInt();
1223 D->VarianceLoc = readSourceLocation();
1224 D->ColonLoc = readSourceLocation();
1225}
1226
1227void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
1228 VisitNamedDecl(ND: CD);
1229 CD->setAtStartLoc(readSourceLocation());
1230 CD->setAtEndRange(readSourceRange());
1231}
1232
1233ObjCTypeParamList *ASTDeclReader::ReadObjCTypeParamList() {
1234 unsigned numParams = Record.readInt();
1235 if (numParams == 0)
1236 return nullptr;
1237
1238 SmallVector<ObjCTypeParamDecl *, 4> typeParams;
1239 typeParams.reserve(N: numParams);
1240 for (unsigned i = 0; i != numParams; ++i) {
1241 auto *typeParam = readDeclAs<ObjCTypeParamDecl>();
1242 if (!typeParam)
1243 return nullptr;
1244
1245 typeParams.push_back(Elt: typeParam);
1246 }
1247
1248 SourceLocation lAngleLoc = readSourceLocation();
1249 SourceLocation rAngleLoc = readSourceLocation();
1250
1251 return ObjCTypeParamList::create(ctx&: Reader.getContext(), lAngleLoc,
1252 typeParams, rAngleLoc);
1253}
1254
1255void ASTDeclReader::ReadObjCDefinitionData(
1256 struct ObjCInterfaceDecl::DefinitionData &Data) {
1257 // Read the superclass.
1258 Data.SuperClassTInfo = readTypeSourceInfo();
1259
1260 Data.EndLoc = readSourceLocation();
1261 Data.HasDesignatedInitializers = Record.readInt();
1262 Data.ODRHash = Record.readInt();
1263 Data.HasODRHash = true;
1264
1265 // Read the directly referenced protocols and their SourceLocations.
1266 unsigned NumProtocols = Record.readInt();
1267 SmallVector<ObjCProtocolDecl *, 16> Protocols;
1268 Protocols.reserve(N: NumProtocols);
1269 for (unsigned I = 0; I != NumProtocols; ++I)
1270 Protocols.push_back(Elt: readDeclAs<ObjCProtocolDecl>());
1271 SmallVector<SourceLocation, 16> ProtoLocs;
1272 ProtoLocs.reserve(N: NumProtocols);
1273 for (unsigned I = 0; I != NumProtocols; ++I)
1274 ProtoLocs.push_back(Elt: readSourceLocation());
1275 Data.ReferencedProtocols.set(InList: Protocols.data(), Elts: NumProtocols, Locs: ProtoLocs.data(),
1276 Ctx&: Reader.getContext());
1277
1278 // Read the transitive closure of protocols referenced by this class.
1279 NumProtocols = Record.readInt();
1280 Protocols.clear();
1281 Protocols.reserve(N: NumProtocols);
1282 for (unsigned I = 0; I != NumProtocols; ++I)
1283 Protocols.push_back(Elt: readDeclAs<ObjCProtocolDecl>());
1284 Data.AllReferencedProtocols.set(InList: Protocols.data(), Elts: NumProtocols,
1285 Ctx&: Reader.getContext());
1286}
1287
1288void ASTDeclMerger::MergeDefinitionData(
1289 ObjCInterfaceDecl *D, struct ObjCInterfaceDecl::DefinitionData &&NewDD) {
1290 struct ObjCInterfaceDecl::DefinitionData &DD = D->data();
1291 if (DD.Definition == NewDD.Definition)
1292 return;
1293
1294 Reader.MergedDeclContexts.insert(
1295 KV: std::make_pair(x&: NewDD.Definition, y&: DD.Definition));
1296 Reader.mergeDefinitionVisibility(Def: DD.Definition, MergedDef: NewDD.Definition);
1297
1298 if (D->getODRHash() != NewDD.ODRHash)
1299 Reader.PendingObjCInterfaceOdrMergeFailures[DD.Definition].push_back(
1300 Elt: {NewDD.Definition, &NewDD});
1301}
1302
1303void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
1304 RedeclarableResult Redecl = VisitRedeclarable(D: ID);
1305 VisitObjCContainerDecl(CD: ID);
1306 DeferredTypeID = Record.getGlobalTypeID(LocalID: Record.readInt());
1307 mergeRedeclarable(DBase: ID, Redecl);
1308
1309 ID->TypeParamList = ReadObjCTypeParamList();
1310 if (Record.readInt()) {
1311 // Read the definition.
1312 ID->allocateDefinitionData();
1313
1314 ReadObjCDefinitionData(Data&: ID->data());
1315 ObjCInterfaceDecl *Canon = ID->getCanonicalDecl();
1316 if (Canon->Data.getPointer()) {
1317 // If we already have a definition, keep the definition invariant and
1318 // merge the data.
1319 MergeImpl.MergeDefinitionData(D: Canon, NewDD: std::move(ID->data()));
1320 ID->Data = Canon->Data;
1321 } else {
1322 // Set the definition data of the canonical declaration, so other
1323 // redeclarations will see it.
1324 ID->getCanonicalDecl()->Data = ID->Data;
1325
1326 // We will rebuild this list lazily.
1327 ID->setIvarList(nullptr);
1328 }
1329
1330 // Note that we have deserialized a definition.
1331 Reader.PendingDefinitions.insert(Ptr: ID);
1332
1333 // Note that we've loaded this Objective-C class.
1334 Reader.ObjCClassesLoaded.push_back(Elt: ID);
1335 } else {
1336 ID->Data = ID->getCanonicalDecl()->Data;
1337 }
1338}
1339
1340void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
1341 VisitFieldDecl(FD: IVD);
1342 IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record.readInt());
1343 // This field will be built lazily.
1344 IVD->setNextIvar(nullptr);
1345 bool synth = Record.readInt();
1346 IVD->setSynthesize(synth);
1347
1348 // Check ivar redeclaration.
1349 if (IVD->isInvalidDecl())
1350 return;
1351 // Don't check ObjCInterfaceDecl as interfaces are named and mismatches can be
1352 // detected in VisitObjCInterfaceDecl. Here we are looking for redeclarations
1353 // in extensions.
1354 if (isa<ObjCInterfaceDecl>(Val: IVD->getDeclContext()))
1355 return;
1356 ObjCInterfaceDecl *CanonIntf =
1357 IVD->getContainingInterface()->getCanonicalDecl();
1358 IdentifierInfo *II = IVD->getIdentifier();
1359 ObjCIvarDecl *PrevIvar = CanonIntf->lookupInstanceVariable(IVarName: II);
1360 if (PrevIvar && PrevIvar != IVD) {
1361 auto *ParentExt = dyn_cast<ObjCCategoryDecl>(Val: IVD->getDeclContext());
1362 auto *PrevParentExt =
1363 dyn_cast<ObjCCategoryDecl>(Val: PrevIvar->getDeclContext());
1364 if (ParentExt && PrevParentExt) {
1365 // Postpone diagnostic as we should merge identical extensions from
1366 // different modules.
1367 Reader
1368 .PendingObjCExtensionIvarRedeclarations[std::make_pair(x&: ParentExt,
1369 y&: PrevParentExt)]
1370 .push_back(Elt: std::make_pair(x&: IVD, y&: PrevIvar));
1371 } else if (ParentExt || PrevParentExt) {
1372 // Duplicate ivars in extension + implementation are never compatible.
1373 // Compatibility of implementation + implementation should be handled in
1374 // VisitObjCImplementationDecl.
1375 Reader.Diag(Loc: IVD->getLocation(), DiagID: diag::err_duplicate_ivar_declaration)
1376 << II;
1377 Reader.Diag(Loc: PrevIvar->getLocation(), DiagID: diag::note_previous_definition);
1378 }
1379 }
1380}
1381
1382void ASTDeclReader::ReadObjCDefinitionData(
1383 struct ObjCProtocolDecl::DefinitionData &Data) {
1384 unsigned NumProtoRefs = Record.readInt();
1385 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
1386 ProtoRefs.reserve(N: NumProtoRefs);
1387 for (unsigned I = 0; I != NumProtoRefs; ++I)
1388 ProtoRefs.push_back(Elt: readDeclAs<ObjCProtocolDecl>());
1389 SmallVector<SourceLocation, 16> ProtoLocs;
1390 ProtoLocs.reserve(N: NumProtoRefs);
1391 for (unsigned I = 0; I != NumProtoRefs; ++I)
1392 ProtoLocs.push_back(Elt: readSourceLocation());
1393 Data.ReferencedProtocols.set(InList: ProtoRefs.data(), Elts: NumProtoRefs,
1394 Locs: ProtoLocs.data(), Ctx&: Reader.getContext());
1395 Data.ODRHash = Record.readInt();
1396 Data.HasODRHash = true;
1397}
1398
1399void ASTDeclMerger::MergeDefinitionData(
1400 ObjCProtocolDecl *D, struct ObjCProtocolDecl::DefinitionData &&NewDD) {
1401 struct ObjCProtocolDecl::DefinitionData &DD = D->data();
1402 if (DD.Definition == NewDD.Definition)
1403 return;
1404
1405 Reader.MergedDeclContexts.insert(
1406 KV: std::make_pair(x&: NewDD.Definition, y&: DD.Definition));
1407 Reader.mergeDefinitionVisibility(Def: DD.Definition, MergedDef: NewDD.Definition);
1408
1409 if (D->getODRHash() != NewDD.ODRHash)
1410 Reader.PendingObjCProtocolOdrMergeFailures[DD.Definition].push_back(
1411 Elt: {NewDD.Definition, &NewDD});
1412}
1413
1414void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
1415 RedeclarableResult Redecl = VisitRedeclarable(D: PD);
1416 VisitObjCContainerDecl(CD: PD);
1417 mergeRedeclarable(DBase: PD, Redecl);
1418
1419 if (Record.readInt()) {
1420 // Read the definition.
1421 PD->allocateDefinitionData();
1422
1423 ReadObjCDefinitionData(Data&: PD->data());
1424
1425 ObjCProtocolDecl *Canon = PD->getCanonicalDecl();
1426 if (Canon->Data.getPointer()) {
1427 // If we already have a definition, keep the definition invariant and
1428 // merge the data.
1429 MergeImpl.MergeDefinitionData(D: Canon, NewDD: std::move(PD->data()));
1430 PD->Data = Canon->Data;
1431 } else {
1432 // Set the definition data of the canonical declaration, so other
1433 // redeclarations will see it.
1434 PD->getCanonicalDecl()->Data = PD->Data;
1435 }
1436 // Note that we have deserialized a definition.
1437 Reader.PendingDefinitions.insert(Ptr: PD);
1438 } else {
1439 PD->Data = PD->getCanonicalDecl()->Data;
1440 }
1441}
1442
1443void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
1444 VisitFieldDecl(FD);
1445}
1446
1447void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
1448 VisitObjCContainerDecl(CD);
1449 CD->setCategoryNameLoc(readSourceLocation());
1450 CD->setIvarLBraceLoc(readSourceLocation());
1451 CD->setIvarRBraceLoc(readSourceLocation());
1452
1453 // Note that this category has been deserialized. We do this before
1454 // deserializing the interface declaration, so that it will consider this
1455 /// category.
1456 Reader.CategoriesDeserialized.insert(Ptr: CD);
1457
1458 CD->ClassInterface = readDeclAs<ObjCInterfaceDecl>();
1459 CD->TypeParamList = ReadObjCTypeParamList();
1460 unsigned NumProtoRefs = Record.readInt();
1461 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
1462 ProtoRefs.reserve(N: NumProtoRefs);
1463 for (unsigned I = 0; I != NumProtoRefs; ++I)
1464 ProtoRefs.push_back(Elt: readDeclAs<ObjCProtocolDecl>());
1465 SmallVector<SourceLocation, 16> ProtoLocs;
1466 ProtoLocs.reserve(N: NumProtoRefs);
1467 for (unsigned I = 0; I != NumProtoRefs; ++I)
1468 ProtoLocs.push_back(Elt: readSourceLocation());
1469 CD->setProtocolList(List: ProtoRefs.data(), Num: NumProtoRefs, Locs: ProtoLocs.data(),
1470 C&: Reader.getContext());
1471
1472 // Protocols in the class extension belong to the class.
1473 if (NumProtoRefs > 0 && CD->ClassInterface && CD->IsClassExtension())
1474 CD->ClassInterface->mergeClassExtensionProtocolList(
1475 List: (ObjCProtocolDecl *const *)ProtoRefs.data(), Num: NumProtoRefs,
1476 C&: Reader.getContext());
1477}
1478
1479void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
1480 VisitNamedDecl(ND: CAD);
1481 CAD->setClassInterface(readDeclAs<ObjCInterfaceDecl>());
1482}
1483
1484void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
1485 VisitNamedDecl(ND: D);
1486 D->setAtLoc(readSourceLocation());
1487 D->setLParenLoc(readSourceLocation());
1488 QualType T = Record.readType();
1489 TypeSourceInfo *TSI = readTypeSourceInfo();
1490 D->setType(T, TSI);
1491 D->setPropertyAttributes((ObjCPropertyAttribute::Kind)Record.readInt());
1492 D->setPropertyAttributesAsWritten(
1493 (ObjCPropertyAttribute::Kind)Record.readInt());
1494 D->setPropertyImplementation(
1495 (ObjCPropertyDecl::PropertyControl)Record.readInt());
1496 DeclarationName GetterName = Record.readDeclarationName();
1497 SourceLocation GetterLoc = readSourceLocation();
1498 D->setGetterName(Sel: GetterName.getObjCSelector(), Loc: GetterLoc);
1499 DeclarationName SetterName = Record.readDeclarationName();
1500 SourceLocation SetterLoc = readSourceLocation();
1501 D->setSetterName(Sel: SetterName.getObjCSelector(), Loc: SetterLoc);
1502 D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1503 D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1504 D->setPropertyIvarDecl(readDeclAs<ObjCIvarDecl>());
1505}
1506
1507void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
1508 VisitObjCContainerDecl(CD: D);
1509 D->setClassInterface(readDeclAs<ObjCInterfaceDecl>());
1510}
1511
1512void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1513 VisitObjCImplDecl(D);
1514 D->CategoryNameLoc = readSourceLocation();
1515}
1516
1517void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1518 VisitObjCImplDecl(D);
1519 D->setSuperClass(readDeclAs<ObjCInterfaceDecl>());
1520 D->SuperLoc = readSourceLocation();
1521 D->setIvarLBraceLoc(readSourceLocation());
1522 D->setIvarRBraceLoc(readSourceLocation());
1523 D->setHasNonZeroConstructors(Record.readInt());
1524 D->setHasDestructors(Record.readInt());
1525 D->NumIvarInitializers = Record.readInt();
1526 if (D->NumIvarInitializers)
1527 D->IvarInitializers = ReadGlobalOffset();
1528}
1529
1530void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
1531 VisitDecl(D);
1532 D->setAtLoc(readSourceLocation());
1533 D->setPropertyDecl(readDeclAs<ObjCPropertyDecl>());
1534 D->PropertyIvarDecl = readDeclAs<ObjCIvarDecl>();
1535 D->IvarLoc = readSourceLocation();
1536 D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1537 D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1538 D->setGetterCXXConstructor(Record.readExpr());
1539 D->setSetterCXXAssignment(Record.readExpr());
1540}
1541
1542void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
1543 VisitDeclaratorDecl(DD: FD);
1544 FD->Mutable = Record.readInt();
1545
1546 unsigned Bits = Record.readInt();
1547 FD->StorageKind = Bits >> 1;
1548 if (FD->StorageKind == FieldDecl::ISK_CapturedVLAType)
1549 FD->CapturedVLAType =
1550 cast<VariableArrayType>(Val: Record.readType().getTypePtr());
1551 else if (Bits & 1)
1552 FD->setBitWidth(Record.readExpr());
1553
1554 if (!FD->getDeclName() ||
1555 FD->isPlaceholderVar(LangOpts: Reader.getContext().getLangOpts())) {
1556 if (auto *Tmpl = readDeclAs<FieldDecl>())
1557 Reader.getContext().setInstantiatedFromUnnamedFieldDecl(Inst: FD, Tmpl);
1558 }
1559 mergeMergeable(D: FD);
1560}
1561
1562void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
1563 VisitDeclaratorDecl(DD: PD);
1564 PD->GetterId = Record.readIdentifier();
1565 PD->SetterId = Record.readIdentifier();
1566}
1567
1568void ASTDeclReader::VisitMSGuidDecl(MSGuidDecl *D) {
1569 VisitValueDecl(VD: D);
1570 D->PartVal.Part1 = Record.readInt();
1571 D->PartVal.Part2 = Record.readInt();
1572 D->PartVal.Part3 = Record.readInt();
1573 for (auto &C : D->PartVal.Part4And5)
1574 C = Record.readInt();
1575
1576 // Add this GUID to the AST context's lookup structure, and merge if needed.
1577 if (MSGuidDecl *Existing = Reader.getContext().MSGuidDecls.getOrInsert(N: D))
1578 Reader.getContext().setPrimaryMergedDecl(D, Primary: Existing->getCanonicalDecl());
1579}
1580
1581void ASTDeclReader::VisitUnnamedGlobalConstantDecl(
1582 UnnamedGlobalConstantDecl *D) {
1583 VisitValueDecl(VD: D);
1584 D->Value = Record.readAPValue();
1585
1586 // Add this to the AST context's lookup structure, and merge if needed.
1587 if (UnnamedGlobalConstantDecl *Existing =
1588 Reader.getContext().UnnamedGlobalConstantDecls.getOrInsert(N: D))
1589 Reader.getContext().setPrimaryMergedDecl(D, Primary: Existing->getCanonicalDecl());
1590}
1591
1592void ASTDeclReader::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
1593 VisitValueDecl(VD: D);
1594 D->Value = Record.readAPValue();
1595
1596 // Add this template parameter object to the AST context's lookup structure,
1597 // and merge if needed.
1598 if (TemplateParamObjectDecl *Existing =
1599 Reader.getContext().TemplateParamObjectDecls.getOrInsert(N: D))
1600 Reader.getContext().setPrimaryMergedDecl(D, Primary: Existing->getCanonicalDecl());
1601}
1602
1603void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
1604 VisitValueDecl(VD: FD);
1605
1606 FD->ChainingSize = Record.readInt();
1607 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1608 FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
1609
1610 for (unsigned I = 0; I != FD->ChainingSize; ++I)
1611 FD->Chaining[I] = readDeclAs<NamedDecl>();
1612
1613 mergeMergeable(D: FD);
1614}
1615
1616RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
1617 RedeclarableResult Redecl = VisitRedeclarable(D: VD);
1618 VisitDeclaratorDecl(DD: VD);
1619
1620 BitsUnpacker VarDeclBits(Record.readInt());
1621 auto VarLinkage = Linkage(VarDeclBits.getNextBits(/*Width=*/3));
1622 bool DefGeneratedInModule = VarDeclBits.getNextBit();
1623 VD->VarDeclBits.SClass = (StorageClass)VarDeclBits.getNextBits(/*Width=*/3);
1624 VD->VarDeclBits.TSCSpec = VarDeclBits.getNextBits(/*Width=*/2);
1625 VD->VarDeclBits.InitStyle = VarDeclBits.getNextBits(/*Width=*/2);
1626 VD->VarDeclBits.ARCPseudoStrong = VarDeclBits.getNextBit();
1627 bool HasDeducedType = false;
1628 if (!isa<ParmVarDecl>(Val: VD)) {
1629 VD->NonParmVarDeclBits.IsThisDeclarationADemotedDefinition =
1630 VarDeclBits.getNextBit();
1631 VD->NonParmVarDeclBits.ExceptionVar = VarDeclBits.getNextBit();
1632 VD->NonParmVarDeclBits.NRVOVariable = VarDeclBits.getNextBit();
1633 VD->NonParmVarDeclBits.CXXForRangeDecl = VarDeclBits.getNextBit();
1634
1635 VD->NonParmVarDeclBits.IsInline = VarDeclBits.getNextBit();
1636 VD->NonParmVarDeclBits.IsInlineSpecified = VarDeclBits.getNextBit();
1637 VD->NonParmVarDeclBits.IsConstexpr = VarDeclBits.getNextBit();
1638 VD->NonParmVarDeclBits.IsInitCapture = VarDeclBits.getNextBit();
1639 VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope =
1640 VarDeclBits.getNextBit();
1641
1642 VD->NonParmVarDeclBits.EscapingByref = VarDeclBits.getNextBit();
1643 HasDeducedType = VarDeclBits.getNextBit();
1644 VD->NonParmVarDeclBits.ImplicitParamKind =
1645 VarDeclBits.getNextBits(/*Width*/ 3);
1646
1647 VD->NonParmVarDeclBits.ObjCForDecl = VarDeclBits.getNextBit();
1648 VD->NonParmVarDeclBits.IsCXXForRangeImplicitVar = VarDeclBits.getNextBit();
1649 }
1650
1651 // If this variable has a deduced type, defer reading that type until we are
1652 // done deserializing this variable, because the type might refer back to the
1653 // variable.
1654 if (HasDeducedType)
1655 Reader.PendingDeducedVarTypes.push_back(Elt: {VD, DeferredTypeID});
1656 else
1657 VD->setType(Reader.GetType(ID: DeferredTypeID));
1658 DeferredTypeID = 0;
1659
1660 VD->setCachedLinkage(VarLinkage);
1661
1662 // Reconstruct the one piece of the IdentifierNamespace that we need.
1663 if (VD->getStorageClass() == SC_Extern && VarLinkage != Linkage::None &&
1664 VD->getLexicalDeclContext()->isFunctionOrMethod())
1665 VD->setLocalExternDecl();
1666
1667 if (DefGeneratedInModule) {
1668 Reader.DefinitionSource[VD] =
1669 Loc.F->Kind == ModuleKind::MK_MainFile ||
1670 Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;
1671 }
1672
1673 if (VD->hasAttr<BlocksAttr>()) {
1674 Expr *CopyExpr = Record.readExpr();
1675 if (CopyExpr)
1676 Reader.getContext().setBlockVarCopyInit(VD, CopyExpr, CanThrow: Record.readInt());
1677 }
1678
1679 enum VarKind {
1680 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1681 };
1682 switch ((VarKind)Record.readInt()) {
1683 case VarNotTemplate:
1684 // Only true variables (not parameters or implicit parameters) can be
1685 // merged; the other kinds are not really redeclarable at all.
1686 if (!isa<ParmVarDecl>(Val: VD) && !isa<ImplicitParamDecl>(Val: VD) &&
1687 !isa<VarTemplateSpecializationDecl>(Val: VD))
1688 mergeRedeclarable(DBase: VD, Redecl);
1689 break;
1690 case VarTemplate:
1691 // Merged when we merge the template.
1692 VD->setDescribedVarTemplate(readDeclAs<VarTemplateDecl>());
1693 break;
1694 case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
1695 auto *Tmpl = readDeclAs<VarDecl>();
1696 auto TSK = (TemplateSpecializationKind)Record.readInt();
1697 SourceLocation POI = readSourceLocation();
1698 Reader.getContext().setInstantiatedFromStaticDataMember(Inst: VD, Tmpl, TSK,PointOfInstantiation: POI);
1699 mergeRedeclarable(DBase: VD, Redecl);
1700 break;
1701 }
1702 }
1703
1704 return Redecl;
1705}
1706
1707void ASTDeclReader::ReadVarDeclInit(VarDecl *VD) {
1708 if (uint64_t Val = Record.readInt()) {
1709 ASTContext &Context = Reader.getContext();
1710 EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1711 Eval->HasConstantInitialization = (Val & 2) != 0;
1712 Eval->HasConstantDestruction = (Val & 4) != 0;
1713 Eval->WasEvaluated = (Val & 8) != 0;
1714 Eval->HasSideEffects = (Val & 16) != 0;
1715 Eval->CheckedForSideEffects = true;
1716 if (Eval->WasEvaluated) {
1717 Eval->Evaluated = Record.readAPValue();
1718 if (Eval->Evaluated.needsCleanup())
1719 Context.addDestruction(Ptr: &Eval->Evaluated);
1720
1721 // The bytecode interpreter has its own internal representation of global
1722 // variables. Notify it that we just deserialized one and what its value
1723 // is. This is important because this declaration might initialize a
1724 // previously declared global (e.g. because that one is extern).
1725 if (Context.getLangOpts().EnableNewConstInterp &&
1726 !VD->getType().isNull() && VD->getPreviousDecl() != nullptr)
1727 Context.getInterpContext().registerRedecl(VD, V: Eval->Evaluated);
1728 }
1729
1730 // Store the offset of the initializer. Don't deserialize it yet: it might
1731 // not be needed, and might refer back to the variable, for example if it
1732 // contains a lambda.
1733 Eval->Value = GetCurrentCursorOffset();
1734 }
1735}
1736
1737void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
1738 VisitVarDecl(VD: PD);
1739}
1740
1741void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
1742 VisitVarDecl(VD: PD);
1743
1744 unsigned scopeIndex = Record.readInt();
1745 BitsUnpacker ParmVarDeclBits(Record.readInt());
1746 unsigned isObjCMethodParam = ParmVarDeclBits.getNextBit();
1747 unsigned scopeDepth = ParmVarDeclBits.getNextBits(/*Width=*/7);
1748 unsigned declQualifier = ParmVarDeclBits.getNextBits(/*Width=*/7);
1749 if (isObjCMethodParam) {
1750 assert(scopeDepth == 0);
1751 PD->setObjCMethodScopeInfo(scopeIndex);
1752 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1753 } else {
1754 PD->setScopeInfo(scopeDepth, parameterIndex: scopeIndex);
1755 }
1756 PD->ParmVarDeclBits.IsKNRPromoted = ParmVarDeclBits.getNextBit();
1757
1758 PD->ParmVarDeclBits.HasInheritedDefaultArg = ParmVarDeclBits.getNextBit();
1759 if (ParmVarDeclBits.getNextBit()) // hasUninstantiatedDefaultArg.
1760 PD->setUninstantiatedDefaultArg(Record.readExpr());
1761
1762 if (ParmVarDeclBits.getNextBit()) // Valid explicit object parameter
1763 PD->ExplicitObjectParameterIntroducerLoc = Record.readSourceLocation();
1764
1765 // FIXME: If this is a redeclaration of a function from another module, handle
1766 // inheritance of default arguments.
1767}
1768
1769void ASTDeclReader::VisitDecompositionDecl(DecompositionDecl *DD) {
1770 VisitVarDecl(VD: DD);
1771 auto **BDs = DD->getTrailingObjects();
1772 for (unsigned I = 0; I != DD->NumBindings; ++I) {
1773 BDs[I] = readDeclAs<BindingDecl>();
1774 BDs[I]->setDecomposedDecl(DD);
1775 }
1776}
1777
1778void ASTDeclReader::VisitBindingDecl(BindingDecl *BD) {
1779 VisitValueDecl(VD: BD);
1780 BD->Binding = Record.readExpr();
1781}
1782
1783void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
1784 VisitDecl(D: AD);
1785 AD->setAsmString(cast<StringLiteral>(Val: Record.readExpr()));
1786 AD->setRParenLoc(readSourceLocation());
1787}
1788
1789void ASTDeclReader::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {
1790 VisitDecl(D);
1791 D->Ordinal = Record.readInt();
1792 // Keep new statements numbered after the ones loaded from an AST file.
1793 ASTContext &Ctx = Reader.getContext();
1794 Ctx.NumTopLevelStmtDecls = std::max(a: Ctx.NumTopLevelStmtDecls, b: D->Ordinal + 1);
1795 D->Statement = Record.readStmt();
1796}
1797
1798void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
1799 VisitDecl(D: BD);
1800 BD->setBody(cast_or_null<CompoundStmt>(Val: Record.readStmt()));
1801 BD->setSignatureAsWritten(readTypeSourceInfo());
1802 unsigned NumParams = Record.readInt();
1803 SmallVector<ParmVarDecl *, 16> Params;
1804 Params.reserve(N: NumParams);
1805 for (unsigned I = 0; I != NumParams; ++I)
1806 Params.push_back(Elt: readDeclAs<ParmVarDecl>());
1807 BD->setParams(Params);
1808
1809 BD->setIsVariadic(Record.readInt());
1810 BD->setBlockMissingReturnType(Record.readInt());
1811 BD->setIsConversionFromLambda(Record.readInt());
1812 BD->setDoesNotEscape(Record.readInt());
1813 BD->setCanAvoidCopyToHeap(Record.readInt());
1814
1815 bool capturesCXXThis = Record.readInt();
1816 unsigned numCaptures = Record.readInt();
1817 SmallVector<BlockDecl::Capture, 16> captures;
1818 captures.reserve(N: numCaptures);
1819 for (unsigned i = 0; i != numCaptures; ++i) {
1820 auto *decl = readDeclAs<VarDecl>();
1821 unsigned flags = Record.readInt();
1822 bool byRef = (flags & 1);
1823 bool nested = (flags & 2);
1824 Expr *copyExpr = ((flags & 4) ? Record.readExpr() : nullptr);
1825
1826 captures.push_back(Elt: BlockDecl::Capture(decl, byRef, nested, copyExpr));
1827 }
1828 BD->setCaptures(Context&: Reader.getContext(), Captures: captures, CapturesCXXThis: capturesCXXThis);
1829}
1830
1831void ASTDeclReader::VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D) {
1832 // NumParams is deserialized by OutlinedFunctionDecl::CreateDeserialized().
1833 VisitDecl(D);
1834 for (unsigned I = 0; I < D->NumParams; ++I)
1835 D->setParam(i: I, P: readDeclAs<ImplicitParamDecl>());
1836 D->setNothrow(Record.readInt() != 0);
1837 D->setBody(cast_or_null<Stmt>(Val: Record.readStmt()));
1838}
1839
1840void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
1841 VisitDecl(D: CD);
1842 unsigned ContextParamPos = Record.readInt();
1843 CD->setNothrow(Record.readInt() != 0);
1844 // Body is set by VisitCapturedStmt.
1845 for (unsigned I = 0; I < CD->NumParams; ++I) {
1846 if (I != ContextParamPos)
1847 CD->setParam(i: I, P: readDeclAs<ImplicitParamDecl>());
1848 else
1849 CD->setContextParam(i: I, P: readDeclAs<ImplicitParamDecl>());
1850 }
1851}
1852
1853void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1854 VisitDecl(D);
1855 D->setLanguage(static_cast<LinkageSpecLanguageIDs>(Record.readInt()));
1856 D->setExternLoc(readSourceLocation());
1857 D->setRBraceLoc(readSourceLocation());
1858}
1859
1860void ASTDeclReader::VisitExportDecl(ExportDecl *D) {
1861 VisitDecl(D);
1862 D->RBraceLoc = readSourceLocation();
1863}
1864
1865void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1866 VisitNamedDecl(ND: D);
1867 D->setLocStart(readSourceLocation());
1868}
1869
1870void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1871 RedeclarableResult Redecl = VisitRedeclarable(D);
1872 VisitNamedDecl(ND: D);
1873
1874 BitsUnpacker NamespaceDeclBits(Record.readInt());
1875 D->setInline(NamespaceDeclBits.getNextBit());
1876 D->setNested(NamespaceDeclBits.getNextBit());
1877 D->LocStart = readSourceLocation();
1878 D->RBraceLoc = readSourceLocation();
1879
1880 // Defer loading the anonymous namespace until we've finished merging
1881 // this namespace; loading it might load a later declaration of the
1882 // same namespace, and we have an invariant that older declarations
1883 // get merged before newer ones try to merge.
1884 GlobalDeclID AnonNamespace;
1885 if (Redecl.getFirstID() == ThisDeclID)
1886 AnonNamespace = readDeclID();
1887
1888 mergeRedeclarable(DBase: D, Redecl);
1889
1890 if (AnonNamespace.isValid()) {
1891 // Each module has its own anonymous namespace, which is disjoint from
1892 // any other module's anonymous namespaces, so don't attach the anonymous
1893 // namespace at all.
1894 auto *Anon = cast<NamespaceDecl>(Val: Reader.GetDecl(ID: AnonNamespace));
1895 if (!Record.isModule())
1896 D->setAnonymousNamespace(Anon);
1897 }
1898}
1899
1900void ASTDeclReader::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
1901 VisitNamedDecl(ND: D);
1902 LookupBlockOffsets Offsets;
1903 VisitDeclContext(DC: D, Offsets);
1904 D->IsCBuffer = Record.readBool();
1905 D->KwLoc = readSourceLocation();
1906 D->LBraceLoc = readSourceLocation();
1907 D->RBraceLoc = readSourceLocation();
1908}
1909
1910void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1911 RedeclarableResult Redecl = VisitRedeclarable(D);
1912 VisitNamedDecl(ND: D);
1913 D->NamespaceLoc = readSourceLocation();
1914 D->IdentLoc = readSourceLocation();
1915 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1916 D->Namespace = readDeclAs<NamespaceBaseDecl>();
1917 mergeRedeclarable(DBase: D, Redecl);
1918}
1919
1920void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1921 VisitNamedDecl(ND: D);
1922 D->setUsingLoc(readSourceLocation());
1923 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1924 D->DNLoc = Record.readDeclarationNameLoc(Name: D->getDeclName());
1925 D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());
1926 D->setTypename(Record.readInt());
1927 if (auto *Pattern = readDeclAs<NamedDecl>())
1928 Reader.getContext().setInstantiatedFromUsingDecl(Inst: D, Pattern);
1929 mergeMergeable(D);
1930}
1931
1932void ASTDeclReader::VisitUsingEnumDecl(UsingEnumDecl *D) {
1933 VisitNamedDecl(ND: D);
1934 D->setUsingLoc(readSourceLocation());
1935 D->setEnumLoc(readSourceLocation());
1936 D->setEnumType(Record.readTypeSourceInfo());
1937 D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());
1938 if (auto *Pattern = readDeclAs<UsingEnumDecl>())
1939 Reader.getContext().setInstantiatedFromUsingEnumDecl(Inst: D, Pattern);
1940 mergeMergeable(D);
1941}
1942
1943void ASTDeclReader::VisitUsingPackDecl(UsingPackDecl *D) {
1944 VisitNamedDecl(ND: D);
1945 D->InstantiatedFrom = readDeclAs<NamedDecl>();
1946 auto **Expansions = D->getTrailingObjects();
1947 for (unsigned I = 0; I != D->NumExpansions; ++I)
1948 Expansions[I] = readDeclAs<NamedDecl>();
1949 mergeMergeable(D);
1950}
1951
1952void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1953 RedeclarableResult Redecl = VisitRedeclarable(D);
1954 VisitNamedDecl(ND: D);
1955 D->Underlying = readDeclAs<NamedDecl>();
1956 D->IdentifierNamespace = Record.readInt();
1957 D->UsingOrNextShadow = readDeclAs<NamedDecl>();
1958 auto *Pattern = readDeclAs<UsingShadowDecl>();
1959 if (Pattern)
1960 Reader.getContext().setInstantiatedFromUsingShadowDecl(Inst: D, Pattern);
1961 mergeRedeclarable(DBase: D, Redecl);
1962}
1963
1964void ASTDeclReader::VisitConstructorUsingShadowDecl(
1965 ConstructorUsingShadowDecl *D) {
1966 VisitUsingShadowDecl(D);
1967 D->NominatedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();
1968 D->ConstructedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();
1969 D->IsVirtual = Record.readInt();
1970}
1971
1972void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1973 VisitNamedDecl(ND: D);
1974 D->UsingLoc = readSourceLocation();
1975 D->NamespaceLoc = readSourceLocation();
1976 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1977 D->NominatedNamespace = readDeclAs<NamedDecl>();
1978 D->CommonAncestor = readDeclAs<DeclContext>();
1979}
1980
1981void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1982 VisitValueDecl(VD: D);
1983 D->setUsingLoc(readSourceLocation());
1984 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1985 D->DNLoc = Record.readDeclarationNameLoc(Name: D->getDeclName());
1986 D->EllipsisLoc = readSourceLocation();
1987 mergeMergeable(D);
1988}
1989
1990void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1991 UnresolvedUsingTypenameDecl *D) {
1992 VisitTypeDecl(TD: D);
1993 D->TypenameLocation = readSourceLocation();
1994 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1995 D->EllipsisLoc = readSourceLocation();
1996 mergeMergeable(D);
1997}
1998
1999void ASTDeclReader::VisitUnresolvedUsingIfExistsDecl(
2000 UnresolvedUsingIfExistsDecl *D) {
2001 VisitNamedDecl(ND: D);
2002}
2003
2004void ASTDeclReader::ReadCXXDefinitionData(
2005 struct CXXRecordDecl::DefinitionData &Data, const CXXRecordDecl *D,
2006 Decl *LambdaContext, unsigned IndexInLambdaContext) {
2007
2008 BitsUnpacker CXXRecordDeclBits = Record.readInt();
2009
2010#define FIELD(Name, Width, Merge) \
2011 if (!CXXRecordDeclBits.canGetNextNBits(Width)) \
2012 CXXRecordDeclBits.updateValue(Record.readInt()); \
2013 Data.Name = CXXRecordDeclBits.getNextBits(Width);
2014
2015#include "clang/AST/CXXRecordDeclDefinitionBits.def"
2016#undef FIELD
2017
2018 // Note: the caller has deserialized the IsLambda bit already.
2019 Data.ODRHash = Record.readInt();
2020 Data.HasODRHash = true;
2021
2022 if (Record.readInt()) {
2023 Reader.DefinitionSource[D] =
2024 Loc.F->Kind == ModuleKind::MK_MainFile ||
2025 Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;
2026 }
2027
2028 Record.readUnresolvedSet(Set&: Data.Conversions);
2029 Data.ComputedVisibleConversions = Record.readInt();
2030 if (Data.ComputedVisibleConversions)
2031 Record.readUnresolvedSet(Set&: Data.VisibleConversions);
2032 assert(Data.Definition && "Data.Definition should be already set!");
2033
2034 if (!Data.IsLambda) {
2035 assert(!LambdaContext && !IndexInLambdaContext &&
2036 "given lambda context for non-lambda");
2037
2038 Data.NumBases = Record.readInt();
2039 if (Data.NumBases)
2040 Data.Bases = ReadGlobalOffset();
2041
2042 Data.NumVBases = Record.readInt();
2043 if (Data.NumVBases)
2044 Data.VBases = ReadGlobalOffset();
2045
2046 Data.FirstFriend = readDeclID().getRawValue();
2047 } else {
2048 using Capture = LambdaCapture;
2049
2050 auto &Lambda = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
2051
2052 BitsUnpacker LambdaBits(Record.readInt());
2053 Lambda.DependencyKind = LambdaBits.getNextBits(/*Width=*/2);
2054 Lambda.IsGenericLambda = LambdaBits.getNextBit();
2055 Lambda.CaptureDefault = LambdaBits.getNextBits(/*Width=*/2);
2056 Lambda.NumCaptures = LambdaBits.getNextBits(/*Width=*/15);
2057 Lambda.HasKnownInternalLinkage = LambdaBits.getNextBit();
2058
2059 Lambda.NumExplicitCaptures = Record.readInt();
2060 Lambda.ManglingNumber = Record.readInt();
2061 if (unsigned DeviceManglingNumber = Record.readInt())
2062 Reader.getContext().DeviceLambdaManglingNumbers[D] = DeviceManglingNumber;
2063 Lambda.IndexInContext = IndexInLambdaContext;
2064 Lambda.ContextDecl = LambdaContext;
2065 Capture *ToCapture = nullptr;
2066 if (Lambda.NumCaptures) {
2067 ToCapture = (Capture *)Reader.getContext().Allocate(Size: sizeof(Capture) *
2068 Lambda.NumCaptures);
2069 Lambda.AddCaptureList(Ctx&: Reader.getContext(), CaptureList: ToCapture);
2070 }
2071 Lambda.MethodTyInfo = readTypeSourceInfo();
2072 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
2073 SourceLocation Loc = readSourceLocation();
2074 BitsUnpacker CaptureBits(Record.readInt());
2075 bool IsImplicit = CaptureBits.getNextBit();
2076 auto Kind =
2077 static_cast<LambdaCaptureKind>(CaptureBits.getNextBits(/*Width=*/3));
2078 switch (Kind) {
2079 case LCK_StarThis:
2080 case LCK_This:
2081 case LCK_VLAType:
2082 new (ToCapture)
2083 Capture(Loc, IsImplicit, Kind, nullptr, SourceLocation());
2084 ToCapture++;
2085 break;
2086 case LCK_ByCopy:
2087 case LCK_ByRef:
2088 auto *Var = readDeclAs<ValueDecl>();
2089 SourceLocation EllipsisLoc = readSourceLocation();
2090 new (ToCapture) Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
2091 ToCapture++;
2092 break;
2093 }
2094 }
2095 }
2096}
2097
2098void ASTDeclMerger::MergeDefinitionData(
2099 CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {
2100 assert(D->DefinitionData &&
2101 "merging class definition into non-definition");
2102 auto &DD = *D->DefinitionData;
2103
2104 if (DD.Definition != MergeDD.Definition) {
2105 // Track that we merged the definitions.
2106 Reader.MergedDeclContexts.insert(KV: std::make_pair(x&: MergeDD.Definition,
2107 y&: DD.Definition));
2108 Reader.PendingDefinitions.erase(Ptr: MergeDD.Definition);
2109 MergeDD.Definition->demoteThisDefinitionToDeclaration();
2110 Reader.mergeDefinitionVisibility(Def: DD.Definition, MergedDef: MergeDD.Definition);
2111 assert(!Reader.Lookups.contains(MergeDD.Definition) &&
2112 "already loaded pending lookups for merged definition");
2113 }
2114
2115 auto PFDI = Reader.PendingFakeDefinitionData.find(Val: &DD);
2116 if (PFDI != Reader.PendingFakeDefinitionData.end() &&
2117 PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {
2118 // We faked up this definition data because we found a class for which we'd
2119 // not yet loaded the definition. Replace it with the real thing now.
2120 assert(!DD.IsLambda && "faked up lambda definition?");
2121
2122 // This is possible for some special loading ordering. See
2123 // clang/test/Modules/pr217858.cppm for an example.
2124 //
2125 // LambdaDefinitionData is larger than DefinitionData, so it cannot replace
2126 // the fake DefinitionData object in place.
2127 if (MergeDD.IsLambda) {
2128 auto *Def = DD.Definition;
2129 MergeDD.Definition = Def;
2130 // Unlike an instantiated class definition,
2131 // whose update-record reader removes the fake entry after loading its
2132 // lexical declarations, a lambda's definition is part of its declaration
2133 // record and is fully loaded here.
2134 Reader.PendingFakeDefinitionData.erase(I: PFDI);
2135 for (auto *R = Reader.getMostRecentExistingDecl(D: Def); R;
2136 R = R->getPreviousDecl())
2137 cast<CXXRecordDecl>(Val: R)->DefinitionData = &MergeDD;
2138 return;
2139 }
2140
2141 PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;
2142
2143 // Don't change which declaration is the definition; that is required
2144 // to be invariant once we select it.
2145 auto *Def = DD.Definition;
2146 DD = std::move(MergeDD);
2147 DD.Definition = Def;
2148 for (auto *R = Reader.getMostRecentExistingDecl(D: Def); R;
2149 R = R->getPreviousDecl())
2150 cast<CXXRecordDecl>(Val: R)->DefinitionData = &DD;
2151 return;
2152 }
2153
2154 bool DetectedOdrViolation = false;
2155
2156 #define FIELD(Name, Width, Merge) Merge(Name)
2157 #define MERGE_OR(Field) DD.Field |= MergeDD.Field;
2158 #define NO_MERGE(Field) \
2159 DetectedOdrViolation |= DD.Field != MergeDD.Field; \
2160 MERGE_OR(Field)
2161 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2162 NO_MERGE(IsLambda)
2163 #undef NO_MERGE
2164 #undef MERGE_OR
2165
2166 if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
2167 DetectedOdrViolation = true;
2168 // FIXME: Issue a diagnostic if the base classes don't match when we come
2169 // to lazily load them.
2170
2171 // FIXME: Issue a diagnostic if the list of conversion functions doesn't
2172 // match when we come to lazily load them.
2173 if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
2174 DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
2175 DD.ComputedVisibleConversions = true;
2176 }
2177
2178 // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
2179 // lazily load it.
2180
2181 if (DD.IsLambda) {
2182 auto &Lambda1 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(DD);
2183 auto &Lambda2 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(MergeDD);
2184 DetectedOdrViolation |= Lambda1.DependencyKind != Lambda2.DependencyKind;
2185 DetectedOdrViolation |= Lambda1.IsGenericLambda != Lambda2.IsGenericLambda;
2186 DetectedOdrViolation |= Lambda1.CaptureDefault != Lambda2.CaptureDefault;
2187 DetectedOdrViolation |= Lambda1.NumCaptures != Lambda2.NumCaptures;
2188 DetectedOdrViolation |=
2189 Lambda1.NumExplicitCaptures != Lambda2.NumExplicitCaptures;
2190 DetectedOdrViolation |=
2191 Lambda1.HasKnownInternalLinkage != Lambda2.HasKnownInternalLinkage;
2192 DetectedOdrViolation |= Lambda1.ManglingNumber != Lambda2.ManglingNumber;
2193
2194 if (Lambda1.NumCaptures && Lambda1.NumCaptures == Lambda2.NumCaptures) {
2195 for (unsigned I = 0, N = Lambda1.NumCaptures; I != N; ++I) {
2196 LambdaCapture &Cap1 = Lambda1.Captures.front()[I];
2197 LambdaCapture &Cap2 = Lambda2.Captures.front()[I];
2198 DetectedOdrViolation |= Cap1.getCaptureKind() != Cap2.getCaptureKind();
2199 }
2200 Lambda1.AddCaptureList(Ctx&: Reader.getContext(), CaptureList: Lambda2.Captures.front());
2201 }
2202 }
2203
2204 // We don't want to check ODR for decls in the global module fragment.
2205 if (shouldSkipCheckingODR(D: MergeDD.Definition) || shouldSkipCheckingODR(D))
2206 return;
2207
2208 if (D->getODRHash() != MergeDD.ODRHash) {
2209 DetectedOdrViolation = true;
2210 }
2211
2212 if (DetectedOdrViolation)
2213 Reader.PendingOdrMergeFailures[DD.Definition].push_back(
2214 Elt: {MergeDD.Definition, &MergeDD});
2215}
2216
2217void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,
2218 Decl *LambdaContext,
2219 unsigned IndexInLambdaContext) {
2220 struct CXXRecordDecl::DefinitionData *DD;
2221 ASTContext &C = Reader.getContext();
2222
2223 // Determine whether this is a lambda closure type, so that we can
2224 // allocate the appropriate DefinitionData structure.
2225 bool IsLambda = Record.readInt();
2226 assert(!(IsLambda && Update) &&
2227 "lambda definition should not be added by update record");
2228 if (IsLambda)
2229 DD = new (C) CXXRecordDecl::LambdaDefinitionData(
2230 D, nullptr, CXXRecordDecl::LDK_Unknown, false, LCD_None);
2231 else
2232 DD = new (C) struct CXXRecordDecl::DefinitionData(D);
2233
2234 CXXRecordDecl *Canon = D->getCanonicalDecl();
2235 // Set decl definition data before reading it, so that during deserialization
2236 // when we read CXXRecordDecl, it already has definition data and we don't
2237 // set fake one.
2238 if (!Canon->DefinitionData)
2239 Canon->DefinitionData = DD;
2240 D->DefinitionData = Canon->DefinitionData;
2241 ReadCXXDefinitionData(Data&: *DD, D, LambdaContext, IndexInLambdaContext);
2242
2243 // Mark this declaration as being a definition.
2244 D->setCompleteDefinition(true);
2245
2246 // We might already have a different definition for this record. This can
2247 // happen either because we're reading an update record, or because we've
2248 // already done some merging. Either way, just merge into it.
2249 if (Canon->DefinitionData != DD) {
2250 MergeImpl.MergeDefinitionData(D: Canon, MergeDD: std::move(*DD));
2251 return;
2252 }
2253
2254 // If this is not the first declaration or is an update record, we can have
2255 // other redeclarations already. Make a note that we need to propagate the
2256 // DefinitionData pointer onto them.
2257 if (Update || Canon != D)
2258 Reader.PendingDefinitions.insert(Ptr: D);
2259}
2260
2261RedeclarableResult ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
2262 RedeclarableResult Redecl = VisitRecordDeclImpl(RD: D);
2263
2264 ASTContext &C = Reader.getContext();
2265
2266 enum CXXRecKind {
2267 CXXRecNotTemplate = 0,
2268 CXXRecTemplate,
2269 CXXRecMemberSpecialization,
2270 CXXLambda
2271 };
2272
2273 Decl *LambdaContext = nullptr;
2274 unsigned IndexInLambdaContext = 0;
2275
2276 switch ((CXXRecKind)Record.readInt()) {
2277 case CXXRecNotTemplate:
2278 // Merged when we merge the folding set entry in the primary template.
2279 if (!isa<ClassTemplateSpecializationDecl>(Val: D))
2280 mergeRedeclarable(DBase: D, Redecl);
2281 break;
2282 case CXXRecTemplate: {
2283 // Merged when we merge the template.
2284 auto *Template = readDeclAs<ClassTemplateDecl>();
2285 D->TemplateOrInstantiation = Template;
2286 break;
2287 }
2288 case CXXRecMemberSpecialization: {
2289 auto *RD = readDeclAs<CXXRecordDecl>();
2290 auto TSK = (TemplateSpecializationKind)Record.readInt();
2291 SourceLocation POI = readSourceLocation();
2292 MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
2293 MSI->setPointOfInstantiation(POI);
2294 D->TemplateOrInstantiation = MSI;
2295 mergeRedeclarable(DBase: D, Redecl);
2296 break;
2297 }
2298 case CXXLambda: {
2299 LambdaContext = readDecl();
2300 if (LambdaContext)
2301 IndexInLambdaContext = Record.readInt();
2302 if (LambdaContext)
2303 MergeImpl.mergeLambda(D, Redecl, Context&: *LambdaContext, Number: IndexInLambdaContext);
2304 else
2305 // If we don't have a mangling context, treat this like any other
2306 // declaration.
2307 mergeRedeclarable(DBase: D, Redecl);
2308 break;
2309 }
2310 }
2311
2312 bool WasDefinition = Record.readInt();
2313 if (WasDefinition)
2314 ReadCXXRecordDefinition(D, /*Update=*/false, LambdaContext,
2315 IndexInLambdaContext);
2316 else
2317 // Propagate DefinitionData pointer from the canonical declaration.
2318 D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
2319
2320 // Lazily load the key function to avoid deserializing every method so we can
2321 // compute it.
2322 if (WasDefinition) {
2323 GlobalDeclID KeyFn = readDeclID();
2324 if (KeyFn.isValid() && D->isCompleteDefinition())
2325 // FIXME: This is wrong for the ARM ABI, where some other module may have
2326 // made this function no longer be a key function. We need an update
2327 // record or similar for that case.
2328 C.KeyFunctions[D] = KeyFn.getRawValue();
2329 }
2330
2331 return Redecl;
2332}
2333
2334void ASTDeclReader::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
2335 D->setExplicitSpecifier(Record.readExplicitSpec());
2336 D->Ctor = readDeclAs<CXXConstructorDecl>();
2337 VisitFunctionDecl(FD: D);
2338 D->setDeductionCandidateKind(
2339 static_cast<DeductionCandidate>(Record.readInt()));
2340 D->setSourceDeductionGuide(readDeclAs<CXXDeductionGuideDecl>());
2341 D->setSourceDeductionGuideKind(
2342 static_cast<CXXDeductionGuideDecl::SourceDeductionGuideKind>(
2343 Record.readInt()));
2344}
2345
2346void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
2347 VisitFunctionDecl(FD: D);
2348
2349 unsigned NumOverridenMethods = Record.readInt();
2350 if (D->isCanonicalDecl()) {
2351 while (NumOverridenMethods--) {
2352 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
2353 // MD may be initializing.
2354 if (auto *MD = readDeclAs<CXXMethodDecl>())
2355 Reader.getContext().addOverriddenMethod(Method: D, Overridden: MD->getCanonicalDecl());
2356 }
2357 } else {
2358 // We don't care about which declarations this used to override; we get
2359 // the relevant information from the canonical declaration.
2360 Record.skipInts(N: NumOverridenMethods);
2361 }
2362}
2363
2364void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2365 // We need the inherited constructor information to merge the declaration,
2366 // so we have to read it before we call VisitCXXMethodDecl.
2367 D->setExplicitSpecifier(Record.readExplicitSpec());
2368 if (D->isInheritingConstructor()) {
2369 auto *Shadow = readDeclAs<ConstructorUsingShadowDecl>();
2370 auto *Ctor = readDeclAs<CXXConstructorDecl>();
2371 *D->getTrailingObjects<InheritedConstructor>() =
2372 InheritedConstructor(Shadow, Ctor);
2373 }
2374
2375 if (unsigned NumArgs = Record.readUInt32()) {
2376 CXXDefaultArgExpr **Args =
2377 new (Reader.getContext()) CXXDefaultArgExpr *[NumArgs];
2378 for (unsigned I = 0; I != NumArgs; I++)
2379 Args[I] = cast_or_null<CXXDefaultArgExpr>(Val: Record.readStmt());
2380 D->setCtorClosureDefaultArgs(ArrayRef(Args, NumArgs));
2381 }
2382
2383 VisitCXXMethodDecl(D);
2384}
2385
2386void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2387 VisitCXXMethodDecl(D);
2388
2389 ASTContext &C = Reader.getContext();
2390 CXXDestructorDecl *Canon = cast<CXXDestructorDecl>(Val: D->getCanonicalDecl());
2391 if (auto *OperatorDelete = readDeclAs<FunctionDecl>()) {
2392 auto *ThisArg = Record.readExpr();
2393 // FIXME: Check consistency if we have an old and new operator delete.
2394 if (!C.dtorHasOperatorDelete(Dtor: D, K: ASTContext::OperatorDeleteKind::Regular)) {
2395 C.addOperatorDeleteForVDtor(Dtor: D, OperatorDelete,
2396 K: ASTContext::OperatorDeleteKind::Regular);
2397 Canon->OperatorDeleteThisArg = ThisArg;
2398 }
2399 }
2400 if (auto *OperatorGlobDelete = readDeclAs<FunctionDecl>()) {
2401 if (!C.dtorHasOperatorDelete(Dtor: D,
2402 K: ASTContext::OperatorDeleteKind::GlobalRegular))
2403 C.addOperatorDeleteForVDtor(
2404 Dtor: D, OperatorDelete: OperatorGlobDelete, K: ASTContext::OperatorDeleteKind::GlobalRegular);
2405 }
2406 if (auto *OperatorArrayDelete = readDeclAs<FunctionDecl>()) {
2407 if (!C.dtorHasOperatorDelete(Dtor: D, K: ASTContext::OperatorDeleteKind::Array))
2408 C.addOperatorDeleteForVDtor(Dtor: D, OperatorDelete: OperatorArrayDelete,
2409 K: ASTContext::OperatorDeleteKind::Array);
2410 }
2411 if (auto *OperatorGlobArrayDelete = readDeclAs<FunctionDecl>()) {
2412 if (!C.dtorHasOperatorDelete(Dtor: D,
2413 K: ASTContext::OperatorDeleteKind::ArrayGlobal))
2414 C.addOperatorDeleteForVDtor(Dtor: D, OperatorDelete: OperatorGlobArrayDelete,
2415 K: ASTContext::OperatorDeleteKind::ArrayGlobal);
2416 }
2417}
2418
2419void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
2420 D->setExplicitSpecifier(Record.readExplicitSpec());
2421 VisitCXXMethodDecl(D);
2422}
2423
2424void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
2425 VisitDecl(D);
2426 D->ImportedModule = readModule();
2427 D->setImportComplete(Record.readInt());
2428 auto *StoredLocs = D->getTrailingObjects();
2429 for (unsigned I = 0, N = Record.back(); I != N; ++I)
2430 StoredLocs[I] = readSourceLocation();
2431 Record.skipInts(N: 1); // The number of stored source locations.
2432}
2433
2434void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
2435 VisitDecl(D);
2436 D->setColonLoc(readSourceLocation());
2437}
2438
2439void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
2440 VisitDecl(D);
2441 if (Record.readInt()) // hasFriendDecl
2442 D->Friend = readDeclAs<NamedDecl>();
2443 else
2444 D->Friend = readTypeSourceInfo();
2445 D->NextFriend = readDeclID().getRawValue();
2446 D->FriendLoc = readSourceLocation();
2447 D->EllipsisLoc = readSourceLocation();
2448}
2449
2450void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
2451 VisitDecl(D);
2452 for (unsigned I = 0; I != D->NumTPLists; ++I)
2453 D->getTrailingObjects()[I] = Record.readTemplateParameterList();
2454 auto Kind = static_cast<FriendTemplateDeclKind>(Record.readInt());
2455 switch (Kind) {
2456 case FTDK_Type:
2457 D->Friend = readTypeSourceInfo();
2458 break;
2459 case FTDK_Decl:
2460 D->Friend = readDeclAs<NamedDecl>();
2461 break;
2462 case FTDK_Template:
2463 D->Template = Record.readTemplateName();
2464 assert(D->Template.getAsTemplateDecl() &&
2465 "friend template name must resolve to a template declaration");
2466 D->Friend = D->Template.getAsTemplateDecl();
2467 break;
2468 case FTDK_Dependent:
2469 D->Friend = readTypeSourceInfo();
2470 D->Template = Record.readTemplateName();
2471 break;
2472 }
2473 D->NextFriend = readDeclID().getRawValue();
2474 D->FriendLoc = readSourceLocation();
2475 D->EllipsisLoc = readSourceLocation();
2476}
2477
2478void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
2479 VisitNamedDecl(ND: D);
2480
2481 assert(!D->TemplateParams && "TemplateParams already set!");
2482 D->TemplateParams = Record.readTemplateParameterList();
2483 D->init(NewTemplatedDecl: readDeclAs<NamedDecl>());
2484}
2485
2486void ASTDeclReader::VisitConceptDecl(ConceptDecl *D) {
2487 VisitTemplateDecl(D);
2488 D->ConstraintExpr = Record.readExpr();
2489 mergeMergeable(D);
2490}
2491
2492void ASTDeclReader::VisitImplicitConceptSpecializationDecl(
2493 ImplicitConceptSpecializationDecl *D) {
2494 // The size of the template list was read during creation of the Decl, so we
2495 // don't have to re-read it here.
2496 VisitDecl(D);
2497 llvm::SmallVector<TemplateArgument, 4> Args;
2498 for (unsigned I = 0; I < D->NumTemplateArgs; ++I)
2499 Args.push_back(Elt: Record.readTemplateArgument(/*Canonicalize=*/false));
2500 D->setTemplateArguments(Args);
2501}
2502
2503void ASTDeclReader::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
2504}
2505
2506void ASTDeclReader::ReadSpecializations(ModuleFile &M, Decl *D,
2507 llvm::BitstreamCursor &DeclsCursor,
2508 bool IsPartial) {
2509 uint64_t Offset = ReadLocalOffset();
2510 bool Failed =
2511 Reader.ReadSpecializations(M, Cursor&: DeclsCursor, Offset, D, IsPartial);
2512 (void)Failed;
2513 assert(!Failed);
2514}
2515
2516RedeclarableResult
2517ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
2518 RedeclarableResult Redecl = VisitRedeclarable(D);
2519
2520 // Make sure we've allocated the Common pointer first. We do this before
2521 // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
2522 RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
2523 if (!CanonD->Common) {
2524 CanonD->Common = CanonD->newCommon(C&: Reader.getContext());
2525 Reader.PendingDefinitions.insert(Ptr: CanonD);
2526 }
2527 D->Common = CanonD->Common;
2528
2529 // If this is the first declaration of the template, fill in the information
2530 // for the 'common' pointer.
2531 if (ThisDeclID == Redecl.getFirstID()) {
2532 if (auto *RTD = readDeclAs<RedeclarableTemplateDecl>()) {
2533 assert(RTD->getKind() == D->getKind() &&
2534 "InstantiatedFromMemberTemplate kind mismatch");
2535 D->setInstantiatedFromMemberTemplate(RTD);
2536 if (Record.readInt())
2537 D->setMemberSpecialization();
2538 }
2539 }
2540
2541 VisitTemplateDecl(D);
2542 D->IdentifierNamespace = Record.readInt();
2543
2544 return Redecl;
2545}
2546
2547void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
2548 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2549 mergeRedeclarableTemplate(D, Redecl);
2550
2551 if (ThisDeclID == Redecl.getFirstID()) {
2552 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
2553 // the specializations.
2554 ReadSpecializations(M&: *Loc.F, D, DeclsCursor&: Loc.F->DeclsCursor, /*IsPartial=*/false);
2555 ReadSpecializations(M&: *Loc.F, D, DeclsCursor&: Loc.F->DeclsCursor, /*IsPartial=*/true);
2556 }
2557}
2558
2559void ASTDeclReader::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
2560 llvm_unreachable("BuiltinTemplates are not serialized");
2561}
2562
2563/// TODO: Unify with ClassTemplateDecl version?
2564/// May require unifying ClassTemplateDecl and
2565/// VarTemplateDecl beyond TemplateDecl...
2566void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
2567 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2568 mergeRedeclarableTemplate(D, Redecl);
2569
2570 if (ThisDeclID == Redecl.getFirstID()) {
2571 // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
2572 // the specializations.
2573 ReadSpecializations(M&: *Loc.F, D, DeclsCursor&: Loc.F->DeclsCursor, /*IsPartial=*/false);
2574 ReadSpecializations(M&: *Loc.F, D, DeclsCursor&: Loc.F->DeclsCursor, /*IsPartial=*/true);
2575 }
2576}
2577
2578RedeclarableResult ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
2579 ClassTemplateSpecializationDecl *D) {
2580 RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
2581
2582 ASTContext &C = Reader.getContext();
2583 if (Decl *InstD = readDecl()) {
2584 if (auto *CTD = dyn_cast<ClassTemplateDecl>(Val: InstD)) {
2585 D->SpecializedTemplate = CTD;
2586 } else {
2587 SmallVector<TemplateArgument, 8> TemplArgs;
2588 Record.readTemplateArgumentList(TemplArgs);
2589 TemplateArgumentList *ArgList
2590 = TemplateArgumentList::CreateCopy(Context&: C, Args: TemplArgs);
2591 auto *PS =
2592 new (C) ClassTemplateSpecializationDecl::
2593 SpecializedPartialSpecialization();
2594 PS->PartialSpecialization
2595 = cast<ClassTemplatePartialSpecializationDecl>(Val: InstD);
2596 PS->TemplateArgs = ArgList;
2597 D->SpecializedTemplate = PS;
2598 }
2599 }
2600
2601 SmallVector<TemplateArgument, 8> TemplArgs;
2602 Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
2603 D->TemplateArgs = TemplateArgumentList::CreateCopy(Context&: C, Args: TemplArgs);
2604 D->PointOfInstantiation = readSourceLocation();
2605 D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
2606 D->StrictPackMatch = Record.readBool();
2607
2608 bool writtenAsCanonicalDecl = Record.readInt();
2609 if (writtenAsCanonicalDecl) {
2610 auto *CanonPattern = readDeclAs<ClassTemplateDecl>();
2611 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2612 // Set this as, or find, the canonical declaration for this specialization
2613 ClassTemplateSpecializationDecl *CanonSpec;
2614 if (auto *Partial = dyn_cast<ClassTemplatePartialSpecializationDecl>(Val: D)) {
2615 CanonSpec =
2616 CanonPattern->getCommonPtr()->PartialSpecializations.getOrInsert(
2617 N: Partial);
2618 } else {
2619 CanonSpec =
2620 CanonPattern->getCommonPtr()->Specializations.getOrInsert(N: D);
2621 }
2622 // If there was already a canonical specialization, merge into it.
2623 if (CanonSpec != D) {
2624 MergeImpl.mergeRedeclarable<TagDecl>(D, Existing: CanonSpec, Redecl);
2625
2626 // This declaration might be a definition. Merge with any existing
2627 // definition.
2628 if (auto *DDD = D->DefinitionData) {
2629 if (CanonSpec->DefinitionData)
2630 MergeImpl.MergeDefinitionData(D: CanonSpec, MergeDD: std::move(*DDD));
2631 else
2632 CanonSpec->DefinitionData = D->DefinitionData;
2633 }
2634 D->DefinitionData = CanonSpec->DefinitionData;
2635 }
2636 }
2637 }
2638
2639 // extern/template keyword locations for explicit instantiations
2640 if (Record.readBool()) {
2641 auto *ExplicitInfo = new (C) ExplicitInstantiationInfo;
2642 ExplicitInfo->ExternKeywordLoc = readSourceLocation();
2643 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();
2644 D->ExplicitInfo = ExplicitInfo;
2645 }
2646
2647 if (Record.readBool())
2648 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2649
2650 return Redecl;
2651}
2652
2653void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
2654 ClassTemplatePartialSpecializationDecl *D) {
2655 // We need to read the template params first because redeclarable is going to
2656 // need them for profiling
2657 TemplateParameterList *Params = Record.readTemplateParameterList();
2658 D->TemplateParams = Params;
2659
2660 RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
2661
2662 // These are read/set from/to the first declaration.
2663 if (ThisDeclID == Redecl.getFirstID()) {
2664 D->InstantiatedFromMember.setPointer(
2665 readDeclAs<ClassTemplatePartialSpecializationDecl>());
2666 D->InstantiatedFromMember.setInt(Record.readInt());
2667 }
2668}
2669
2670void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
2671 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2672
2673 if (ThisDeclID == Redecl.getFirstID()) {
2674 // This FunctionTemplateDecl owns a CommonPtr; read it.
2675 ReadSpecializations(M&: *Loc.F, D, DeclsCursor&: Loc.F->DeclsCursor, /*IsPartial=*/false);
2676 }
2677}
2678
2679/// TODO: Unify with ClassTemplateSpecializationDecl version?
2680/// May require unifying ClassTemplate(Partial)SpecializationDecl and
2681/// VarTemplate(Partial)SpecializationDecl with a new data
2682/// structure Template(Partial)SpecializationDecl, and
2683/// using Template(Partial)SpecializationDecl as input type.
2684RedeclarableResult ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
2685 VarTemplateSpecializationDecl *D) {
2686 ASTContext &C = Reader.getContext();
2687 if (Decl *InstD = readDecl()) {
2688 if (auto *VTD = dyn_cast<VarTemplateDecl>(Val: InstD)) {
2689 D->SpecializedTemplate = VTD;
2690 } else {
2691 SmallVector<TemplateArgument, 8> TemplArgs;
2692 Record.readTemplateArgumentList(TemplArgs);
2693 TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
2694 Context&: C, Args: TemplArgs);
2695 auto *PS =
2696 new (C)
2697 VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
2698 PS->PartialSpecialization =
2699 cast<VarTemplatePartialSpecializationDecl>(Val: InstD);
2700 PS->TemplateArgs = ArgList;
2701 D->SpecializedTemplate = PS;
2702 }
2703 }
2704
2705 // extern/template keyword locations for explicit instantiations
2706 if (Record.readBool()) {
2707 auto *ExplicitInfo = new (C) ExplicitInstantiationInfo;
2708 ExplicitInfo->ExternKeywordLoc = readSourceLocation();
2709 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();
2710 D->ExplicitInfo = ExplicitInfo;
2711 }
2712
2713 if (Record.readBool())
2714 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2715
2716 SmallVector<TemplateArgument, 8> TemplArgs;
2717 Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
2718 D->TemplateArgs = TemplateArgumentList::CreateCopy(Context&: C, Args: TemplArgs);
2719 D->PointOfInstantiation = readSourceLocation();
2720 D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
2721 D->IsCompleteDefinition = Record.readInt();
2722
2723 RedeclarableResult Redecl = VisitVarDeclImpl(VD: D);
2724
2725 bool writtenAsCanonicalDecl = Record.readInt();
2726 if (writtenAsCanonicalDecl) {
2727 auto *CanonPattern = readDeclAs<VarTemplateDecl>();
2728 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2729 VarTemplateSpecializationDecl *CanonSpec;
2730 if (auto *Partial = dyn_cast<VarTemplatePartialSpecializationDecl>(Val: D)) {
2731 CanonSpec =
2732 CanonPattern->getCommonPtr()->PartialSpecializations.getOrInsert(
2733 N: Partial);
2734 } else {
2735 CanonSpec =
2736 CanonPattern->getCommonPtr()->Specializations.getOrInsert(N: D);
2737 }
2738 // If we already have a matching specialization, merge it.
2739 if (CanonSpec != D)
2740 MergeImpl.mergeRedeclarable<VarDecl>(D, Existing: CanonSpec, Redecl);
2741 }
2742 }
2743
2744 return Redecl;
2745}
2746
2747/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
2748/// May require unifying ClassTemplate(Partial)SpecializationDecl and
2749/// VarTemplate(Partial)SpecializationDecl with a new data
2750/// structure Template(Partial)SpecializationDecl, and
2751/// using Template(Partial)SpecializationDecl as input type.
2752void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
2753 VarTemplatePartialSpecializationDecl *D) {
2754 TemplateParameterList *Params = Record.readTemplateParameterList();
2755 D->TemplateParams = Params;
2756
2757 RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
2758
2759 // These are read/set from/to the first declaration.
2760 if (ThisDeclID == Redecl.getFirstID()) {
2761 D->InstantiatedFromMember.setPointer(
2762 readDeclAs<VarTemplatePartialSpecializationDecl>());
2763 D->InstantiatedFromMember.setInt(Record.readInt());
2764 }
2765}
2766
2767void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
2768 VisitTypeDecl(TD: D);
2769
2770 D->setDeclaredWithTypename(Record.readInt());
2771
2772 bool TypeConstraintInitialized = D->hasTypeConstraint() && Record.readBool();
2773 if (TypeConstraintInitialized) {
2774 ConceptReference *CR = nullptr;
2775 if (Record.readBool())
2776 CR = Record.readConceptReference();
2777 Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
2778 UnsignedOrNone ArgPackSubstIndex = Record.readUnsignedOrNone();
2779
2780 D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint, ArgPackSubstIndex);
2781 D->NumExpanded = Record.readUnsignedOrNone();
2782 }
2783
2784 if (Record.readInt())
2785 D->setDefaultArgument(C: Reader.getContext(),
2786 DefArg: Record.readTemplateArgumentLoc());
2787}
2788
2789void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
2790 VisitDeclaratorDecl(DD: D);
2791 // TemplateParmPosition.
2792 D->setDepth(Record.readInt());
2793 D->setPosition(Record.readInt());
2794 if (D->hasPlaceholderTypeConstraint())
2795 D->setPlaceholderTypeConstraint(Record.readExpr());
2796 if (D->isExpandedParameterPack()) {
2797 auto TypesAndInfos =
2798 D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
2799 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2800 new (&TypesAndInfos[I].first) QualType(Record.readType());
2801 TypesAndInfos[I].second = readTypeSourceInfo();
2802 }
2803 } else {
2804 // Rest of NonTypeTemplateParmDecl.
2805 D->ParameterPack = Record.readInt();
2806 if (Record.readInt())
2807 D->setDefaultArgument(C: Reader.getContext(),
2808 DefArg: Record.readTemplateArgumentLoc());
2809 }
2810}
2811
2812void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
2813 VisitTemplateDecl(D);
2814 D->ParameterKind = static_cast<TemplateNameKind>(Record.readInt());
2815 D->setDeclaredWithTypename(Record.readBool());
2816 // TemplateParmPosition.
2817 D->setDepth(Record.readInt());
2818 D->setPosition(Record.readInt());
2819 if (D->isExpandedParameterPack()) {
2820 auto **Data = D->getTrailingObjects();
2821 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2822 I != N; ++I)
2823 Data[I] = Record.readTemplateParameterList();
2824 } else {
2825 // Rest of TemplateTemplateParmDecl.
2826 D->ParameterPack = Record.readInt();
2827 if (Record.readInt())
2828 D->setDefaultArgument(C: Reader.getContext(),
2829 DefArg: Record.readTemplateArgumentLoc());
2830 }
2831}
2832
2833void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2834 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2835 mergeRedeclarableTemplate(D, Redecl);
2836}
2837
2838void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
2839 VisitDecl(D);
2840 D->AssertExprAndFailed.setPointer(Record.readExpr());
2841 D->AssertExprAndFailed.setInt(Record.readInt());
2842 D->Message = cast_or_null<StringLiteral>(Val: Record.readExpr());
2843 D->RParenLoc = readSourceLocation();
2844}
2845
2846void ASTDeclReader::VisitExplicitInstantiationDecl(
2847 ExplicitInstantiationDecl *D) {
2848 // Note: trailing flags were already read by ReadDeclRecord and passed to
2849 // CreateDeserialized, so TypeAndFlags.getInt() is already set.
2850 VisitDecl(D);
2851 auto *Spec = readDeclAs<NamedDecl>();
2852 D->SpecAndTSK.setPointer(Spec);
2853 D->ExternLoc = readSourceLocation();
2854 D->NameLoc = readSourceLocation();
2855 TypeSourceInfo *TSI = readTypeSourceInfo();
2856 unsigned TSK = Record.readInt();
2857 D->SpecAndTSK.setInt(TSK);
2858 D->TypeAndFlags.setPointer(TSI); // preserves trailing flags in int bits
2859 // Read trailing objects.
2860 if (D->hasTrailingQualifier())
2861 *D->getTrailingObjects<NestedNameSpecifierLoc>() =
2862 Record.readNestedNameSpecifierLoc();
2863 if (D->hasTrailingArgsAsWritten())
2864 *D->getTrailingObjects<const ASTTemplateArgumentListInfo *>() =
2865 Record.readASTTemplateArgumentListInfo();
2866
2867 // Rebuild the ASTContext map from specialization to EID.
2868 if (Spec)
2869 Reader.getContext().addExplicitInstantiationDecl(Spec, EID: D);
2870}
2871
2872void ASTDeclReader::VisitCXXExpansionStmtDecl(CXXExpansionStmtDecl *D) {
2873 VisitDecl(D);
2874 D->Pattern = cast<CXXExpansionStmtPattern>(Val: Record.readStmt());
2875 D->Instantiations =
2876 cast_or_null<CXXExpansionStmtInstantiation>(Val: Record.readStmt());
2877 D->IndexNTTP = cast<NonTypeTemplateParmDecl>(Val: Record.readDeclRef());
2878}
2879
2880void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
2881 VisitDecl(D);
2882}
2883
2884void ASTDeclReader::VisitLifetimeExtendedTemporaryDecl(
2885 LifetimeExtendedTemporaryDecl *D) {
2886 VisitDecl(D);
2887 D->ExtendingDecl = readDeclAs<ValueDecl>();
2888 D->ExprWithTemporary = Record.readStmt();
2889 if (Record.readInt()) {
2890 D->Value = new (D->getASTContext()) APValue(Record.readAPValue());
2891 D->getASTContext().addDestruction(Ptr: D->Value);
2892 }
2893 D->ManglingNumber = Record.readInt();
2894 mergeMergeable(D);
2895}
2896
2897void ASTDeclReader::VisitDeclContext(DeclContext *DC,
2898 LookupBlockOffsets &Offsets) {
2899 Offsets.LexicalOffset = ReadLocalOffset();
2900 Offsets.VisibleOffset = ReadLocalOffset();
2901 Offsets.ModuleLocalOffset = ReadLocalOffset();
2902 Offsets.TULocalOffset = ReadLocalOffset();
2903}
2904
2905template <typename T>
2906RedeclarableResult ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
2907 GlobalDeclID FirstDeclID = readDeclID();
2908 Decl *MergeWith = nullptr;
2909
2910 bool IsKeyDecl = ThisDeclID == FirstDeclID;
2911 bool IsFirstLocalDecl = false;
2912
2913 uint64_t RedeclOffset = 0;
2914
2915 // invalid FirstDeclID indicates that this declaration was the only
2916 // declaration of its entity, and is used for space optimization.
2917 if (FirstDeclID.isInvalid()) {
2918 FirstDeclID = ThisDeclID;
2919 IsKeyDecl = true;
2920 IsFirstLocalDecl = true;
2921 } else if (unsigned N = Record.readInt()) {
2922 // This declaration was the first local declaration, but may have imported
2923 // other declarations.
2924 IsKeyDecl = N == 1;
2925 IsFirstLocalDecl = true;
2926
2927 // We have some declarations that must be before us in our redeclaration
2928 // chain. Read them now, and remember that we ought to merge with one of
2929 // them.
2930 // FIXME: Provide a known merge target to the second and subsequent such
2931 // declaration.
2932 for (unsigned I = 0; I != N - 1; ++I)
2933 MergeWith = readDecl();
2934
2935 RedeclOffset = ReadLocalOffset();
2936 } else {
2937 // This declaration was not the first local declaration. Read the first
2938 // local declaration now, to trigger the import of other redeclarations.
2939 (void)readDecl();
2940 }
2941
2942 auto *FirstDecl = cast_or_null<T>(Reader.GetDecl(ID: FirstDeclID));
2943 if (FirstDecl != D) {
2944 // We delay loading of the redeclaration chain to avoid deeply nested calls.
2945 // We temporarily set the first (canonical) declaration as the previous one
2946 // which is the one that matters and mark the real previous DeclID to be
2947 // loaded & attached later on.
2948 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
2949 D->First = FirstDecl->getCanonicalDecl();
2950 }
2951
2952 auto *DAsT = static_cast<T *>(D);
2953
2954 // Note that we need to load local redeclarations of this decl and build a
2955 // decl chain for them. This must happen *after* we perform the preloading
2956 // above; this ensures that the redeclaration chain is built in the correct
2957 // order.
2958 if (IsFirstLocalDecl)
2959 Reader.PendingDeclChains.push_back(Elt: std::make_pair(DAsT, RedeclOffset));
2960
2961 return RedeclarableResult(MergeWith, FirstDeclID, IsKeyDecl);
2962}
2963
2964/// Attempts to merge the given declaration (D) with another declaration
2965/// of the same entity.
2966template <typename T>
2967void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
2968 RedeclarableResult &Redecl) {
2969 // If modules are not available, there is no reason to perform this merge.
2970 if (!Reader.getContext().getLangOpts().Modules)
2971 return;
2972
2973 // If we're not the canonical declaration, we don't need to merge.
2974 if (!DBase->isFirstDecl())
2975 return;
2976
2977 auto *D = static_cast<T *>(DBase);
2978
2979 if (auto *Existing = Redecl.getKnownMergeTarget())
2980 // We already know of an existing declaration we should merge with.
2981 MergeImpl.mergeRedeclarable(D, cast<T>(Existing), Redecl);
2982 else if (FindExistingResult ExistingRes = findExisting(D))
2983 if (T *Existing = ExistingRes)
2984 MergeImpl.mergeRedeclarable(D, Existing, Redecl);
2985}
2986
2987/// Attempt to merge D with a previous declaration of the same lambda, which is
2988/// found by its index within its context declaration, if it has one.
2989///
2990/// We can't look up lambdas in their enclosing lexical or semantic context in
2991/// general, because for lambdas in variables, both of those might be a
2992/// namespace or the translation unit.
2993void ASTDeclMerger::mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl,
2994 Decl &Context, unsigned IndexInContext) {
2995 // If modules are not available, there is no reason to perform this merge.
2996 if (!Reader.getContext().getLangOpts().Modules)
2997 return;
2998
2999 // If we're not the canonical declaration, we don't need to merge.
3000 if (!D->isFirstDecl())
3001 return;
3002
3003 if (auto *Existing = Redecl.getKnownMergeTarget())
3004 // We already know of an existing declaration we should merge with.
3005 mergeRedeclarable(D, Existing: cast<TagDecl>(Val: Existing), Redecl);
3006
3007 // Look up this lambda to see if we've seen it before. If so, merge with the
3008 // one we already loaded.
3009 auto *&Slot = Reader.getContext().getLambdaDeclarationSlotForMerging(
3010 ContextDecl: &Context, IndexInContext);
3011 if (TagDecl *PrevDecl = Slot)
3012 mergeRedeclarable(D, Existing: PrevDecl, Redecl);
3013 else
3014 Slot = D;
3015}
3016
3017void ASTDeclReader::mergeRedeclarableTemplate(RedeclarableTemplateDecl *D,
3018 RedeclarableResult &Redecl) {
3019 mergeRedeclarable(DBase: D, Redecl);
3020 // If we merged the template with a prior declaration chain, merge the
3021 // common pointer.
3022 // FIXME: Actually merge here, don't just overwrite.
3023 D->Common = D->getCanonicalDecl()->Common;
3024}
3025
3026/// "Cast" to type T, asserting if we don't have an implicit conversion.
3027/// We use this to put code in a template that will only be valid for certain
3028/// instantiations.
3029template<typename T> static T assert_cast(T t) { return t; }
3030template<typename T> static T assert_cast(...) {
3031 llvm_unreachable("bad assert_cast");
3032}
3033
3034/// Merge together the pattern declarations from two template
3035/// declarations.
3036void ASTDeclMerger::mergeTemplatePattern(RedeclarableTemplateDecl *D,
3037 RedeclarableTemplateDecl *Existing,
3038 bool IsKeyDecl) {
3039 auto *DPattern = D->getTemplatedDecl();
3040 auto *ExistingPattern = Existing->getTemplatedDecl();
3041 RedeclarableResult Result(
3042 /*MergeWith*/ ExistingPattern,
3043 DPattern->getCanonicalDecl()->getGlobalID(), IsKeyDecl);
3044
3045 if (auto *DClass = dyn_cast<CXXRecordDecl>(Val: DPattern)) {
3046 // Merge with any existing definition.
3047 // FIXME: This is duplicated in several places. Refactor.
3048 auto *ExistingClass =
3049 cast<CXXRecordDecl>(Val: ExistingPattern)->getCanonicalDecl();
3050 if (auto *DDD = DClass->DefinitionData) {
3051 if (ExistingClass->DefinitionData) {
3052 MergeDefinitionData(D: ExistingClass, MergeDD: std::move(*DDD));
3053 } else {
3054 ExistingClass->DefinitionData = DClass->DefinitionData;
3055 // We may have skipped this before because we thought that DClass
3056 // was the canonical declaration.
3057 Reader.PendingDefinitions.insert(Ptr: DClass);
3058 }
3059 }
3060 DClass->DefinitionData = ExistingClass->DefinitionData;
3061
3062 return mergeRedeclarable(D: DClass, Existing: cast<TagDecl>(Val: ExistingPattern),
3063 Redecl&: Result);
3064 }
3065 if (auto *DFunction = dyn_cast<FunctionDecl>(Val: DPattern))
3066 return mergeRedeclarable(D: DFunction, Existing: cast<FunctionDecl>(Val: ExistingPattern),
3067 Redecl&: Result);
3068 if (auto *DVar = dyn_cast<VarDecl>(Val: DPattern))
3069 return mergeRedeclarable(D: DVar, Existing: cast<VarDecl>(Val: ExistingPattern), Redecl&: Result);
3070 if (auto *DAlias = dyn_cast<TypeAliasDecl>(Val: DPattern))
3071 return mergeRedeclarable(D: DAlias, Existing: cast<TypedefNameDecl>(Val: ExistingPattern),
3072 Redecl&: Result);
3073 llvm_unreachable("merged an unknown kind of redeclarable template");
3074}
3075
3076/// Attempts to merge the given declaration (D) with another declaration
3077/// of the same entity.
3078template <typename T>
3079void ASTDeclMerger::mergeRedeclarableImpl(Redeclarable<T> *DBase, T *Existing,
3080 GlobalDeclID KeyDeclID) {
3081 auto *D = static_cast<T *>(DBase);
3082 T *ExistingCanon = Existing->getCanonicalDecl();
3083 T *DCanon = D->getCanonicalDecl();
3084 if (ExistingCanon != DCanon) {
3085 // Have our redeclaration link point back at the canonical declaration
3086 // of the existing declaration, so that this declaration has the
3087 // appropriate canonical declaration.
3088 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
3089 D->First = ExistingCanon;
3090 ExistingCanon->Used |= D->Used;
3091 D->Used = false;
3092
3093 bool IsKeyDecl = KeyDeclID.isValid();
3094
3095 // When we merge a template, merge its pattern.
3096 if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
3097 mergeTemplatePattern(
3098 D: DTemplate, Existing: assert_cast<RedeclarableTemplateDecl *>(ExistingCanon),
3099 IsKeyDecl);
3100
3101 // If this declaration is a key declaration, make a note of that.
3102 if (IsKeyDecl)
3103 Reader.KeyDecls[ExistingCanon].push_back(KeyDeclID);
3104 }
3105}
3106
3107/// ODR-like semantics for C/ObjC allow us to merge tag types and a structural
3108/// check in Sema guarantees the types can be merged (see C11 6.2.7/1 or C89
3109/// 6.1.2.6/1). Although most merging is done in Sema, we need to guarantee
3110/// that some types are mergeable during deserialization, otherwise name
3111/// lookup fails. This is the case for EnumConstantDecl.
3112static bool allowODRLikeMergeInC(NamedDecl *ND) {
3113 if (!ND)
3114 return false;
3115 // TODO: implement merge for other necessary decls.
3116 if (isa<EnumConstantDecl, FieldDecl, IndirectFieldDecl>(Val: ND))
3117 return true;
3118 return false;
3119}
3120
3121/// Attempts to merge LifetimeExtendedTemporaryDecl with
3122/// identical class definitions from two different modules.
3123void ASTDeclReader::mergeMergeable(LifetimeExtendedTemporaryDecl *D) {
3124 // If modules are not available, there is no reason to perform this merge.
3125 if (!Reader.getContext().getLangOpts().Modules)
3126 return;
3127
3128 LifetimeExtendedTemporaryDecl *LETDecl = D;
3129
3130 LifetimeExtendedTemporaryDecl *&LookupResult =
3131 Reader.LETemporaryForMerging[std::make_pair(
3132 x: LETDecl->getExtendingDecl(), y: LETDecl->getManglingNumber())];
3133 if (LookupResult)
3134 Reader.getContext().setPrimaryMergedDecl(D: LETDecl,
3135 Primary: LookupResult->getCanonicalDecl());
3136 else
3137 LookupResult = LETDecl;
3138}
3139
3140/// Attempts to merge the given declaration (D) with another declaration
3141/// of the same entity, for the case where the entity is not actually
3142/// redeclarable. This happens, for instance, when merging the fields of
3143/// identical class definitions from two different modules.
3144template<typename T>
3145void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
3146 // If modules are not available, there is no reason to perform this merge.
3147 if (!Reader.getContext().getLangOpts().Modules)
3148 return;
3149
3150 // ODR-based merging is performed in C++ and in some cases (tag types) in C.
3151 // Note that C identically-named things in different translation units are
3152 // not redeclarations, but may still have compatible types, where ODR-like
3153 // semantics may apply.
3154 if (!Reader.getContext().getLangOpts().CPlusPlus &&
3155 !allowODRLikeMergeInC(dyn_cast<NamedDecl>(static_cast<T*>(D))))
3156 return;
3157
3158 if (FindExistingResult ExistingRes = findExisting(D: static_cast<T*>(D)))
3159 if (T *Existing = ExistingRes)
3160 Reader.getContext().setPrimaryMergedDecl(D: static_cast<T *>(D),
3161 Primary: Existing->getCanonicalDecl());
3162}
3163
3164void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
3165 Record.readOMPChildren(Data: D->Data);
3166 VisitDecl(D);
3167}
3168
3169void ASTDeclReader::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
3170 Record.readOMPChildren(Data: D->Data);
3171 VisitDecl(D);
3172}
3173
3174void ASTDeclReader::VisitOMPRequiresDecl(OMPRequiresDecl * D) {
3175 Record.readOMPChildren(Data: D->Data);
3176 VisitDecl(D);
3177}
3178
3179void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
3180 VisitValueDecl(VD: D);
3181 D->setLocation(readSourceLocation());
3182 Expr *In = Record.readExpr();
3183 Expr *Out = Record.readExpr();
3184 D->setCombinerData(InE: In, OutE: Out);
3185 Expr *Combiner = Record.readExpr();
3186 D->setCombiner(Combiner);
3187 Expr *Orig = Record.readExpr();
3188 Expr *Priv = Record.readExpr();
3189 D->setInitializerData(OrigE: Orig, PrivE: Priv);
3190 Expr *Init = Record.readExpr();
3191 auto IK = static_cast<OMPDeclareReductionInitKind>(Record.readInt());
3192 D->setInitializer(E: Init, IK);
3193 D->PrevDeclInScope = readDeclID().getRawValue();
3194}
3195
3196void ASTDeclReader::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
3197 Record.readOMPChildren(Data: D->Data);
3198 VisitValueDecl(VD: D);
3199 D->VarName = Record.readDeclarationName();
3200 D->PrevDeclInScope = readDeclID().getRawValue();
3201}
3202
3203void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
3204 VisitVarDecl(VD: D);
3205}
3206
3207void ASTDeclReader::VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D) {
3208 VisitDecl(D);
3209 D->DirKind = Record.readEnum<OpenACCDirectiveKind>();
3210 D->DirectiveLoc = Record.readSourceLocation();
3211 D->EndLoc = Record.readSourceLocation();
3212 Record.readOpenACCClauseList(Clauses: D->Clauses);
3213}
3214void ASTDeclReader::VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D) {
3215 VisitDecl(D);
3216 D->DirKind = Record.readEnum<OpenACCDirectiveKind>();
3217 D->DirectiveLoc = Record.readSourceLocation();
3218 D->EndLoc = Record.readSourceLocation();
3219 D->ParensLoc = Record.readSourceRange();
3220 D->FuncRef = Record.readExpr();
3221 Record.readOpenACCClauseList(Clauses: D->Clauses);
3222}
3223
3224//===----------------------------------------------------------------------===//
3225// Attribute Reading
3226//===----------------------------------------------------------------------===//
3227
3228namespace {
3229class AttrReader {
3230 ASTRecordReader &Reader;
3231
3232public:
3233 AttrReader(ASTRecordReader &Reader) : Reader(Reader) {}
3234
3235 uint64_t readInt() {
3236 return Reader.readInt();
3237 }
3238
3239 bool readBool() { return Reader.readBool(); }
3240
3241 SourceRange readSourceRange() {
3242 return Reader.readSourceRange();
3243 }
3244
3245 SourceLocation readSourceLocation() {
3246 return Reader.readSourceLocation();
3247 }
3248
3249 Expr *readExpr() { return Reader.readExpr(); }
3250
3251 Attr *readAttr() { return Reader.readAttr(); }
3252
3253 std::string readString() {
3254 return Reader.readString();
3255 }
3256
3257 TypeSourceInfo *readTypeSourceInfo() {
3258 return Reader.readTypeSourceInfo();
3259 }
3260
3261 IdentifierInfo *readIdentifier() {
3262 return Reader.readIdentifier();
3263 }
3264
3265 VersionTuple readVersionTuple() {
3266 return Reader.readVersionTuple();
3267 }
3268
3269 OMPTraitInfo *readOMPTraitInfo() { return Reader.readOMPTraitInfo(); }
3270
3271 template <typename T> T *readDeclAs() { return Reader.readDeclAs<T>(); }
3272};
3273}
3274
3275Attr *ASTRecordReader::readAttr() {
3276 AttrReader Record(*this);
3277 auto V = Record.readInt();
3278 if (!V)
3279 return nullptr;
3280
3281 Attr *New = nullptr;
3282 // Kind is stored as a 1-based integer because 0 is used to indicate a null
3283 // Attr pointer.
3284 auto Kind = static_cast<attr::Kind>(V - 1);
3285 ASTContext &Context = getContext();
3286
3287 IdentifierInfo *AttrName = Record.readIdentifier();
3288 IdentifierInfo *ScopeName = Record.readIdentifier();
3289 SourceRange AttrRange = Record.readSourceRange();
3290 SourceLocation ScopeLoc = Record.readSourceLocation();
3291 unsigned ParsedKind = Record.readInt();
3292 unsigned Syntax = Record.readInt();
3293 unsigned SpellingIndex = Record.readInt();
3294 bool IsAlignas = (ParsedKind == AttributeCommonInfo::AT_Aligned &&
3295 Syntax == AttributeCommonInfo::AS_Keyword &&
3296 SpellingIndex == AlignedAttr::Keyword_alignas);
3297 bool IsRegularKeywordAttribute = Record.readBool();
3298
3299 AttributeCommonInfo Info(AttrName, AttributeScopeInfo(ScopeName, ScopeLoc),
3300 AttrRange, AttributeCommonInfo::Kind(ParsedKind),
3301 {AttributeCommonInfo::Syntax(Syntax), SpellingIndex,
3302 IsAlignas, IsRegularKeywordAttribute});
3303
3304#include "clang/Serialization/AttrPCHRead.inc"
3305
3306 assert(New && "Unable to decode attribute?");
3307 return New;
3308}
3309
3310/// Reads attributes from the current stream position.
3311void ASTRecordReader::readAttributes(AttrVec &Attrs) {
3312 for (unsigned I = 0, E = readInt(); I != E; ++I)
3313 if (auto *A = readAttr())
3314 Attrs.push_back(Elt: A);
3315}
3316
3317//===----------------------------------------------------------------------===//
3318// ASTReader Implementation
3319//===----------------------------------------------------------------------===//
3320
3321/// Note that we have loaded the declaration with the given
3322/// Index.
3323///
3324/// This routine notes that this declaration has already been loaded,
3325/// so that future GetDecl calls will return this declaration rather
3326/// than trying to load a new declaration.
3327inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
3328 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
3329 DeclsLoaded[Index] = D;
3330}
3331
3332/// Determine whether the consumer will be interested in seeing
3333/// this declaration (via HandleTopLevelDecl).
3334///
3335/// This routine should return true for anything that might affect
3336/// code generation, e.g., inline function definitions, Objective-C
3337/// declarations with metadata, etc.
3338bool ASTReader::isConsumerInterestedIn(Decl *D) {
3339 // An ObjCMethodDecl is never considered as "interesting" because its
3340 // implementation container always is.
3341
3342 // An ImportDecl or VarDecl imported from a module map module will get
3343 // emitted when we import the relevant module.
3344 if (isPartOfPerModuleInitializer(D)) {
3345 auto *M = D->getImportedOwningModule();
3346 if (M && M->Kind == Module::ModuleMapModule &&
3347 getContext().DeclMustBeEmitted(D))
3348 return false;
3349 }
3350
3351 if (isa<FileScopeAsmDecl, TopLevelStmtDecl, ObjCProtocolDecl, ObjCImplDecl,
3352 ImportDecl, PragmaCommentDecl, PragmaDetectMismatchDecl>(Val: D))
3353 return true;
3354 if (isa<OMPThreadPrivateDecl, OMPDeclareReductionDecl, OMPDeclareMapperDecl,
3355 OMPAllocateDecl, OMPRequiresDecl>(Val: D))
3356 return !D->getDeclContext()->isFunctionOrMethod();
3357 if (const auto *Var = dyn_cast<VarDecl>(Val: D))
3358 return Var->isFileVarDecl() &&
3359 (Var->isThisDeclarationADefinition() == VarDecl::Definition ||
3360 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD: Var));
3361 if (const auto *Func = dyn_cast<FunctionDecl>(Val: D))
3362 return Func->doesThisDeclarationHaveABody() || PendingBodies.count(Key: D);
3363
3364 if (auto *ES = D->getASTContext().getExternalSource())
3365 if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
3366 return true;
3367
3368 return false;
3369}
3370
3371/// Get the correct cursor and offset for loading a declaration.
3372ASTReader::RecordLocation ASTReader::DeclCursorForID(GlobalDeclID ID,
3373 SourceLocation &Loc) {
3374 ModuleFile *M = getOwningModuleFile(ID);
3375 assert(M);
3376 unsigned LocalDeclIndex = ID.getLocalDeclIndex();
3377 const DeclOffset &DOffs = M->DeclOffsets[LocalDeclIndex];
3378 Loc = ReadSourceLocation(MF&: *M, Raw: DOffs.getRawLoc());
3379 return RecordLocation(M, DOffs.getBitOffset(DeclTypesBlockStartOffset: M->DeclsBlockStartOffset));
3380}
3381
3382ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
3383 auto I = GlobalBitOffsetsMap.find(K: GlobalOffset);
3384
3385 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
3386 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
3387}
3388
3389uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset) {
3390 return LocalOffset + M.GlobalBitOffset;
3391}
3392
3393CXXRecordDecl *
3394ASTDeclReader::getOrFakePrimaryClassDefinition(ASTReader &Reader,
3395 CXXRecordDecl *RD) {
3396 // Try to dig out the definition.
3397 auto *DD = RD->DefinitionData;
3398 if (!DD)
3399 DD = RD->getCanonicalDecl()->DefinitionData;
3400
3401 // If there's no definition yet, then DC's definition is added by an update
3402 // record, but we've not yet loaded that update record. In this case, we
3403 // commit to DC being the canonical definition now, and will fix this when
3404 // we load the update record.
3405 if (!DD) {
3406 DD = new (Reader.getContext()) struct CXXRecordDecl::DefinitionData(RD);
3407 RD->setCompleteDefinition(true);
3408 RD->DefinitionData = DD;
3409 RD->getCanonicalDecl()->DefinitionData = DD;
3410
3411 // Track that we did this horrible thing so that we can fix it later.
3412 Reader.PendingFakeDefinitionData.insert(
3413 KV: std::make_pair(x&: DD, y: ASTReader::PendingFakeDefinitionKind::Fake));
3414 }
3415
3416 return DD->Definition;
3417}
3418
3419/// Find the context in which we should search for previous declarations when
3420/// looking for declarations to merge.
3421DeclContext *ASTDeclReader::getPrimaryContextForMerging(ASTReader &Reader,
3422 DeclContext *DC) {
3423 if (auto *ND = dyn_cast<NamespaceDecl>(Val: DC))
3424 return ND->getFirstDecl();
3425
3426 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: DC))
3427 return getOrFakePrimaryClassDefinition(Reader, RD);
3428
3429 if (auto *RD = dyn_cast<RecordDecl>(Val: DC))
3430 return RD->getDefinition();
3431
3432 if (auto *ED = dyn_cast<EnumDecl>(Val: DC))
3433 return ED->getDefinition();
3434
3435 if (auto *OID = dyn_cast<ObjCInterfaceDecl>(Val: DC))
3436 return OID->getDefinition();
3437
3438 // We can see the TU here only if we have no Sema object. It is possible
3439 // we're in clang-repl so we still need to get the primary context.
3440 if (auto *TU = dyn_cast<TranslationUnitDecl>(Val: DC))
3441 return TU->getPrimaryContext();
3442
3443 return nullptr;
3444}
3445
3446ASTDeclReader::FindExistingResult::~FindExistingResult() {
3447 // Record that we had a typedef name for linkage whether or not we merge
3448 // with that declaration.
3449 if (TypedefNameForLinkage) {
3450 DeclContext *DC = New->getDeclContext()->getRedeclContext();
3451 Reader.ImportedTypedefNamesForLinkage.insert(
3452 KV: std::make_pair(x: std::make_pair(x&: DC, y&: TypedefNameForLinkage), y&: New));
3453 return;
3454 }
3455
3456 if (!AddResult || Existing)
3457 return;
3458
3459 DeclarationName Name = New->getDeclName();
3460 DeclContext *DC = New->getDeclContext()->getRedeclContext();
3461 if (needsAnonymousDeclarationNumber(D: New)) {
3462 setAnonymousDeclForMerging(Reader, DC: New->getLexicalDeclContext(),
3463 Index: AnonymousDeclNumber, D: New);
3464 } else if (DC->isTranslationUnit() &&
3465 !Reader.getContext().getLangOpts().CPlusPlus) {
3466 if (Reader.getIdResolver().tryAddTopLevelDecl(D: New, Name))
3467 Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]
3468 .push_back(Elt: New);
3469 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
3470 // Add the declaration to its redeclaration context so later merging
3471 // lookups will find it.
3472 MergeDC->makeDeclVisibleInContextImpl(D: New, /*Internal*/true);
3473 }
3474}
3475
3476/// Find the declaration that should be merged into, given the declaration found
3477/// by name lookup. If we're not merging with a UsingShadowDecl but Found is a
3478/// UsingShadowDecl, we need to skip the UsingShadowDecl. If we're merging an
3479/// anonymous declaration within a typedef, we need a matching typedef, and we
3480/// merge with the type inside it.
3481static NamedDecl *getDeclForMerging(NamedDecl *Found,
3482 bool IsTypedefNameForLinkage,
3483 bool FilteringUsingShadowDecl) {
3484 // If the taregt declaration we want is not a UsingShadowDecl, we don't need
3485 // to return the UsingShadowDecl at all.
3486 if (auto *USD = dyn_cast<UsingShadowDecl>(Val: Found);
3487 USD && FilteringUsingShadowDecl)
3488 return getDeclForMerging(Found: USD->getTargetDecl(), IsTypedefNameForLinkage,
3489 FilteringUsingShadowDecl);
3490
3491 if (!IsTypedefNameForLinkage)
3492 return Found;
3493
3494 // If we found a typedef declaration that gives a name to some other
3495 // declaration, then we want that inner declaration. Declarations from
3496 // AST files are handled via ImportedTypedefNamesForLinkage.
3497 if (Found->isFromASTFile())
3498 return nullptr;
3499
3500 if (auto *TND = dyn_cast<TypedefNameDecl>(Val: Found))
3501 return TND->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
3502
3503 return nullptr;
3504}
3505
3506/// Find the declaration to use to populate the anonymous declaration table
3507/// for the given lexical DeclContext. We only care about finding local
3508/// definitions of the context; we'll merge imported ones as we go.
3509DeclContext *
3510ASTDeclReader::getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC) {
3511 // For classes, we track the definition as we merge.
3512 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: LexicalDC)) {
3513 auto *DD = RD->getCanonicalDecl()->DefinitionData;
3514 return DD ? DD->Definition : nullptr;
3515 } else if (auto *OID = dyn_cast<ObjCInterfaceDecl>(Val: LexicalDC)) {
3516 return OID->getCanonicalDecl()->getDefinition();
3517 }
3518
3519 // For anything else, walk its merged redeclarations looking for a definition.
3520 // Note that we can't just call getDefinition here because the redeclaration
3521 // chain isn't wired up.
3522 for (auto *D : merged_redecls(D: cast<Decl>(Val: LexicalDC))) {
3523 if (auto *FD = dyn_cast<FunctionDecl>(Val: D))
3524 if (FD->isThisDeclarationADefinition())
3525 return FD;
3526 if (auto *MD = dyn_cast<ObjCMethodDecl>(Val: D))
3527 if (MD->isThisDeclarationADefinition())
3528 return MD;
3529 if (auto *RD = dyn_cast<RecordDecl>(Val: D))
3530 if (RD->isThisDeclarationADefinition())
3531 return RD;
3532 }
3533
3534 // No merged definition yet.
3535 return nullptr;
3536}
3537
3538NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
3539 DeclContext *DC,
3540 unsigned Index) {
3541 // If the lexical context has been merged, look into the now-canonical
3542 // definition.
3543 auto *CanonDC = cast<Decl>(Val: DC)->getCanonicalDecl();
3544
3545 // If we've seen this before, return the canonical declaration.
3546 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
3547 if (Index < Previous.size() && Previous[Index])
3548 return Previous[Index];
3549
3550 // If this is the first time, but we have parsed a declaration of the context,
3551 // build the anonymous declaration list from the parsed declaration.
3552 auto *PrimaryDC = getPrimaryDCForAnonymousDecl(LexicalDC: DC);
3553 auto needToNumberAnonymousDeclsWithin = [](Decl *D) {
3554 if (!D->isFromASTFile())
3555 return true;
3556 // If this is a class template specialization from an AST file, has at least
3557 // one field, but none of the fields have been loaded from external storage,
3558 // this is a situation where the class template specialization decl
3559 // was imported but the definition was instantiated within the source.
3560 // In such a case, we still need to number the anonymous decls.
3561 auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Val: D);
3562 return CTSD && !CTSD->noload_field_empty() &&
3563 !CTSD->hasLoadedFieldsFromExternalStorage();
3564 };
3565 if (PrimaryDC && needToNumberAnonymousDeclsWithin(cast<Decl>(Val: PrimaryDC))) {
3566 numberAnonymousDeclsWithin(DC: PrimaryDC, Visit: [&](NamedDecl *ND, unsigned Number) {
3567 if (Previous.size() == Number)
3568 Previous.push_back(Elt: cast<NamedDecl>(Val: ND->getCanonicalDecl()));
3569 else
3570 Previous[Number] = cast<NamedDecl>(Val: ND->getCanonicalDecl());
3571 });
3572 }
3573
3574 return Index < Previous.size() ? Previous[Index] : nullptr;
3575}
3576
3577void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
3578 DeclContext *DC, unsigned Index,
3579 NamedDecl *D) {
3580 auto *CanonDC = cast<Decl>(Val: DC)->getCanonicalDecl();
3581
3582 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
3583 if (Index >= Previous.size())
3584 Previous.resize(N: Index + 1);
3585 if (!Previous[Index])
3586 Previous[Index] = D;
3587}
3588
3589ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
3590 DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
3591 : D->getDeclName();
3592
3593 if (!Name && !needsAnonymousDeclarationNumber(D)) {
3594 // Don't bother trying to find unnamed declarations that are in
3595 // unmergeable contexts.
3596 FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
3597 AnonymousDeclNumber, TypedefNameForLinkage);
3598 Result.suppress();
3599 return Result;
3600 }
3601
3602 ASTContext &C = Reader.getContext();
3603 DeclContext *DC = D->getDeclContext()->getRedeclContext();
3604 if (TypedefNameForLinkage) {
3605 auto It = Reader.ImportedTypedefNamesForLinkage.find(
3606 Val: std::make_pair(x&: DC, y&: TypedefNameForLinkage));
3607 if (It != Reader.ImportedTypedefNamesForLinkage.end())
3608 if (C.isSameEntity(X: It->second, Y: D))
3609 return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
3610 TypedefNameForLinkage);
3611 // Go on to check in other places in case an existing typedef name
3612 // was not imported.
3613 }
3614
3615 if (needsAnonymousDeclarationNumber(D)) {
3616 // This is an anonymous declaration that we may need to merge. Look it up
3617 // in its context by number.
3618 if (auto *Existing = getAnonymousDeclForMerging(
3619 Reader, DC: D->getLexicalDeclContext(), Index: AnonymousDeclNumber))
3620 if (C.isSameEntity(X: Existing, Y: D))
3621 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3622 TypedefNameForLinkage);
3623 } else if (DC->isTranslationUnit() &&
3624 !Reader.getContext().getLangOpts().CPlusPlus) {
3625 IdentifierResolver &IdResolver = Reader.getIdResolver();
3626
3627 // Temporarily consider the identifier to be up-to-date. We don't want to
3628 // cause additional lookups here.
3629 class UpToDateIdentifierRAII {
3630 IdentifierInfo *II;
3631 bool WasOutToDate = false;
3632
3633 public:
3634 explicit UpToDateIdentifierRAII(IdentifierInfo *II) : II(II) {
3635 if (II) {
3636 WasOutToDate = II->isOutOfDate();
3637 if (WasOutToDate)
3638 II->setOutOfDate(false);
3639 }
3640 }
3641
3642 ~UpToDateIdentifierRAII() {
3643 if (WasOutToDate)
3644 II->setOutOfDate(true);
3645 }
3646 } UpToDate(Name.getAsIdentifierInfo());
3647
3648 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
3649 IEnd = IdResolver.end();
3650 I != IEnd; ++I) {
3651 if (NamedDecl *Existing =
3652 getDeclForMerging(Found: *I, IsTypedefNameForLinkage: TypedefNameForLinkage,
3653 /*FilteringUsingShadowDecl=*/false))
3654 if (C.isSameEntity(X: Existing, Y: D))
3655 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3656 TypedefNameForLinkage);
3657 }
3658 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
3659 DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
3660 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
3661 if (NamedDecl *Existing = getDeclForMerging(Found: *I, IsTypedefNameForLinkage: TypedefNameForLinkage,
3662 FilteringUsingShadowDecl: !isa<UsingShadowDecl>(Val: D)))
3663 if (C.isSameEntity(X: Existing, Y: D)) {
3664 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3665 TypedefNameForLinkage);
3666 }
3667 }
3668 } else {
3669 // Not in a mergeable context.
3670 return FindExistingResult(Reader);
3671 }
3672
3673 // If this declaration is from a merged context, make a note that we need to
3674 // check that the canonical definition of that context contains the decl.
3675 //
3676 // Note that we don't perform ODR checks for decls from the global module
3677 // fragment.
3678 //
3679 // FIXME: We should do something similar if we merge two definitions of the
3680 // same template specialization into the same CXXRecordDecl.
3681 auto MergedDCIt = Reader.MergedDeclContexts.find(Val: D->getLexicalDeclContext());
3682 if (MergedDCIt != Reader.MergedDeclContexts.end() &&
3683 !shouldSkipCheckingODR(D) && MergedDCIt->second == D->getDeclContext() &&
3684 !shouldSkipCheckingODR(D: cast<Decl>(Val: D->getDeclContext())))
3685 Reader.PendingOdrMergeChecks.push_back(Elt: D);
3686
3687 return FindExistingResult(Reader, D, /*Existing=*/nullptr,
3688 AnonymousDeclNumber, TypedefNameForLinkage);
3689}
3690
3691template<typename DeclT>
3692Decl *ASTDeclReader::getMostRecentDeclImpl(Redeclarable<DeclT> *D) {
3693 return D->RedeclLink.getLatestNotUpdated();
3694}
3695
3696Decl *ASTDeclReader::getMostRecentDeclImpl(...) {
3697 llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");
3698}
3699
3700Decl *ASTDeclReader::getMostRecentDecl(Decl *D) {
3701 assert(D);
3702
3703 switch (D->getKind()) {
3704#define ABSTRACT_DECL(TYPE)
3705#define DECL(TYPE, BASE) \
3706 case Decl::TYPE: \
3707 return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
3708#include "clang/AST/DeclNodes.inc"
3709 }
3710 llvm_unreachable("unknown decl kind");
3711}
3712
3713Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
3714 return ASTDeclReader::getMostRecentDecl(D: D->getCanonicalDecl());
3715}
3716
3717namespace {
3718void mergeInheritableAttributes(ASTReader &Reader, Decl *D, Decl *Previous) {
3719 InheritableAttr *NewAttr = nullptr;
3720 ASTContext &Context = Reader.getContext();
3721 const auto *IA = Previous->getAttr<MSInheritanceAttr>();
3722
3723 if (IA && !D->hasAttr<MSInheritanceAttr>()) {
3724 NewAttr = cast<InheritableAttr>(Val: IA->clone(C&: Context));
3725 NewAttr->setInherited(true);
3726 D->addAttr(A: NewAttr);
3727 }
3728
3729 if (!D->hasAttr<AvailabilityAttr>()) {
3730 for (const auto *AA : Previous->specific_attrs<AvailabilityAttr>()) {
3731 NewAttr = AA->clone(C&: Context);
3732 NewAttr->setInherited(true);
3733 D->addAttr(A: NewAttr);
3734 }
3735 }
3736}
3737} // namespace
3738
3739template<typename DeclT>
3740void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
3741 Redeclarable<DeclT> *D,
3742 Decl *Previous, Decl *Canon) {
3743 D->RedeclLink.setPrevious(cast<DeclT>(Previous));
3744 D->First = cast<DeclT>(Previous)->First;
3745}
3746
3747namespace clang {
3748
3749template<>
3750void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
3751 Redeclarable<VarDecl> *D,
3752 Decl *Previous, Decl *Canon) {
3753 auto *PrevVD = cast<VarDecl>(Val: Previous);
3754 D->RedeclLink.setPrevious(PrevVD);
3755 D->First = PrevVD->First;
3756
3757 // We should keep at most one definition on the chain.
3758 // FIXME: Cache the definition once we've found it. Building a chain with
3759 // N definitions currently takes O(N^2) time here.
3760 auto *VD = static_cast<VarDecl *>(D);
3761 if (VD->isThisDeclarationADefinition() == VarDecl::Definition) {
3762 for (VarDecl *CurD = PrevVD; CurD; CurD = CurD->getPreviousDecl()) {
3763 if (CurD->isThisDeclarationADefinition() == VarDecl::Definition) {
3764 // FIXME: For header modules, there are some problems if we don't
3765 // demote definition to declaration.
3766 // See clang/test/Modules/module-init-forcelly-loaded-module.cpp
3767 // for example. Maybe we are able to handle the CodeGen part
3768 // to avoid it emitting duplicated definitions. But just workaround
3769 // now temporarily.
3770 if (VD->getOwningModule() &&
3771 VD->getOwningModule()->isHeaderLikeModule())
3772 VD->demoteThisDefinitionToDeclaration();
3773 Reader.mergeDefinitionVisibility(Def: CurD, MergedDef: VD);
3774 break;
3775 }
3776 }
3777 }
3778}
3779
3780static bool isUndeducedReturnType(QualType T) {
3781 auto *DT = T->getContainedDeducedType();
3782 return DT && !DT->isDeduced();
3783}
3784
3785template<>
3786void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
3787 Redeclarable<FunctionDecl> *D,
3788 Decl *Previous, Decl *Canon) {
3789 auto *FD = static_cast<FunctionDecl *>(D);
3790 auto *PrevFD = cast<FunctionDecl>(Val: Previous);
3791
3792 FD->RedeclLink.setPrevious(PrevFD);
3793 FD->First = PrevFD->First;
3794
3795 // If the previous declaration is an inline function declaration, then this
3796 // declaration is too.
3797 if (PrevFD->isInlined() != FD->isInlined()) {
3798 // FIXME: [dcl.fct.spec]p4:
3799 // If a function with external linkage is declared inline in one
3800 // translation unit, it shall be declared inline in all translation
3801 // units in which it appears.
3802 //
3803 // Be careful of this case:
3804 //
3805 // module A:
3806 // template<typename T> struct X { void f(); };
3807 // template<typename T> inline void X<T>::f() {}
3808 //
3809 // module B instantiates the declaration of X<int>::f
3810 // module C instantiates the definition of X<int>::f
3811 //
3812 // If module B and C are merged, we do not have a violation of this rule.
3813 FD->setImplicitlyInline(true);
3814 }
3815
3816 auto *FPT = FD->getType()->getAs<FunctionProtoType>();
3817 auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
3818 if (FPT && PrevFPT) {
3819 // If we need to propagate an exception specification along the redecl
3820 // chain, make a note of that so that we can do so later.
3821 bool IsUnresolved = isUnresolvedExceptionSpec(ESpecType: FPT->getExceptionSpecType());
3822 bool WasUnresolved =
3823 isUnresolvedExceptionSpec(ESpecType: PrevFPT->getExceptionSpecType());
3824 if (IsUnresolved != WasUnresolved)
3825 Reader.PendingExceptionSpecUpdates.insert(
3826 KV: {Canon, IsUnresolved ? PrevFD : FD});
3827
3828 // If we need to propagate a deduced return type along the redecl chain,
3829 // make a note of that so that we can do it later.
3830 bool IsUndeduced = isUndeducedReturnType(T: FPT->getReturnType());
3831 bool WasUndeduced = isUndeducedReturnType(T: PrevFPT->getReturnType());
3832 if (IsUndeduced != WasUndeduced)
3833 Reader.PendingDeducedTypeUpdates.insert(
3834 KV: {cast<FunctionDecl>(Val: Canon),
3835 (IsUndeduced ? PrevFPT : FPT)->getReturnType()});
3836 }
3837}
3838
3839} // namespace clang
3840
3841void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) {
3842 llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
3843}
3844
3845/// Inherit the default template argument from \p From to \p To. Returns
3846/// \c false if there is no default template for \p From.
3847template <typename ParmDecl>
3848static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From,
3849 Decl *ToD) {
3850 auto *To = cast<ParmDecl>(ToD);
3851 if (!From->hasDefaultArgument())
3852 return false;
3853 To->setInheritedDefaultArgument(Context, From);
3854 return true;
3855}
3856
3857static void inheritDefaultTemplateArguments(ASTContext &Context,
3858 TemplateDecl *From,
3859 TemplateDecl *To) {
3860 auto *FromTP = From->getTemplateParameters();
3861 auto *ToTP = To->getTemplateParameters();
3862 assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");
3863
3864 for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {
3865 NamedDecl *FromParam = FromTP->getParam(Idx: I);
3866 NamedDecl *ToParam = ToTP->getParam(Idx: I);
3867
3868 if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(Val: FromParam))
3869 inheritDefaultTemplateArgument(Context, From: FTTP, ToD: ToParam);
3870 else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(Val: FromParam))
3871 inheritDefaultTemplateArgument(Context, From: FNTTP, ToD: ToParam);
3872 else
3873 inheritDefaultTemplateArgument(
3874 Context, From: cast<TemplateTemplateParmDecl>(Val: FromParam), ToD: ToParam);
3875 }
3876}
3877
3878// [basic.link]/p10:
3879// If two declarations of an entity are attached to different modules,
3880// the program is ill-formed;
3881void ASTDeclReader::checkMultipleDefinitionInNamedModules(ASTReader &Reader,
3882 Decl *D,
3883 Decl *Previous) {
3884 // If it is previous implcitly introduced, it is not meaningful to
3885 // diagnose it.
3886 if (Previous->isImplicit())
3887 return;
3888
3889 // FIXME: Get rid of the enumeration of decl types once we have an appropriate
3890 // abstract for decls of an entity. e.g., the namespace decl and using decl
3891 // doesn't introduce an entity.
3892 if (!isa<VarDecl, FunctionDecl, TagDecl, RedeclarableTemplateDecl>(Val: Previous))
3893 return;
3894
3895 // Skip implicit instantiations since it may give false positive diagnostic
3896 // messages.
3897 // FIXME: Maybe this shows the implicit instantiations may have incorrect
3898 // module owner ships. But given we've finished the compilation of a module,
3899 // how can we add new entities to that module?
3900 if (isa<VarTemplateSpecializationDecl>(Val: Previous))
3901 return;
3902 if (isa<ClassTemplateSpecializationDecl>(Val: Previous))
3903 return;
3904 if (auto *Func = dyn_cast<FunctionDecl>(Val: Previous);
3905 Func && Func->getTemplateSpecializationInfo())
3906 return;
3907
3908 // The module ownership of in-class friend declaration is not straightforward.
3909 // Avoid diagnosing such cases.
3910 if (D->getFriendObjectKind() || Previous->getFriendObjectKind())
3911 return;
3912
3913 // Skip diagnosing in-class declarations.
3914 if (!Previous->getLexicalDeclContext()
3915 ->getNonTransparentContext()
3916 ->isFileContext() ||
3917 !D->getLexicalDeclContext()->getNonTransparentContext()->isFileContext())
3918 return;
3919
3920 Module *M = Previous->getOwningModule();
3921 if (!M)
3922 return;
3923
3924 // We only forbids merging decls within named modules.
3925 if (!M->isNamedModule()) {
3926 // Try to warn the case that we merged decls from global module.
3927 if (!M->isGlobalModule())
3928 return;
3929
3930 if (D->getOwningModule() &&
3931 M->getTopLevelModule() == D->getOwningModule()->getTopLevelModule())
3932 return;
3933
3934 Reader.PendingWarningForDuplicatedDefsInModuleUnits.push_back(
3935 Elt: {D, Previous});
3936 return;
3937 }
3938
3939 // It is fine if they are in the same module.
3940 if (Reader.getContext().isInSameModule(M1: M, M2: D->getOwningModule()))
3941 return;
3942
3943 Reader.Diag(Loc: Previous->getLocation(),
3944 DiagID: diag::err_multiple_decl_in_different_modules)
3945 << cast<NamedDecl>(Val: Previous) << M->Name;
3946 Reader.Diag(Loc: D->getLocation(), DiagID: diag::note_also_found);
3947}
3948
3949void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,
3950 Decl *Previous, Decl *Canon) {
3951 assert(D && Previous);
3952
3953 switch (D->getKind()) {
3954#define ABSTRACT_DECL(TYPE)
3955#define DECL(TYPE, BASE) \
3956 case Decl::TYPE: \
3957 attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
3958 break;
3959#include "clang/AST/DeclNodes.inc"
3960 }
3961
3962 checkMultipleDefinitionInNamedModules(Reader, D, Previous);
3963
3964 // If the declaration was visible in one module, a redeclaration of it in
3965 // another module remains visible even if it wouldn't be visible by itself.
3966 //
3967 // FIXME: In this case, the declaration should only be visible if a module
3968 // that makes it visible has been imported.
3969 D->IdentifierNamespace |=
3970 Previous->IdentifierNamespace &
3971 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
3972
3973 // If the declaration declares a template, it may inherit default arguments
3974 // from the previous declaration.
3975 if (auto *TD = dyn_cast<TemplateDecl>(Val: D))
3976 inheritDefaultTemplateArguments(Context&: Reader.getContext(),
3977 From: cast<TemplateDecl>(Val: Previous), To: TD);
3978
3979 // If any of the declaration in the chain contains an Inheritable attribute,
3980 // it needs to be added to all the declarations in the redeclarable chain.
3981 // FIXME: Only the logic of merging MSInheritableAttr is present, it should
3982 // be extended for all inheritable attributes.
3983 mergeInheritableAttributes(Reader, D, Previous);
3984}
3985
3986template<typename DeclT>
3987void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
3988 D->RedeclLink.setLatest(cast<DeclT>(Latest));
3989}
3990
3991void ASTDeclReader::attachLatestDeclImpl(...) {
3992 llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
3993}
3994
3995void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
3996 assert(D && Latest);
3997
3998 switch (D->getKind()) {
3999#define ABSTRACT_DECL(TYPE)
4000#define DECL(TYPE, BASE) \
4001 case Decl::TYPE: \
4002 attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
4003 break;
4004#include "clang/AST/DeclNodes.inc"
4005 }
4006}
4007
4008template<typename DeclT>
4009void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
4010 D->RedeclLink.markIncomplete();
4011}
4012
4013void ASTDeclReader::markIncompleteDeclChainImpl(...) {
4014 llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
4015}
4016
4017void ASTReader::markIncompleteDeclChain(Decl *D) {
4018 switch (D->getKind()) {
4019#define ABSTRACT_DECL(TYPE)
4020#define DECL(TYPE, BASE) \
4021 case Decl::TYPE: \
4022 ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
4023 break;
4024#include "clang/AST/DeclNodes.inc"
4025 }
4026}
4027
4028/// Read the declaration at the given offset from the AST file.
4029Decl *ASTReader::ReadDeclRecord(GlobalDeclID ID) {
4030 SourceLocation DeclLoc;
4031 RecordLocation Loc = DeclCursorForID(ID, Loc&: DeclLoc);
4032 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
4033 // Keep track of where we are in the stream, then jump back there
4034 // after reading this declaration.
4035 SavedStreamPosition SavedPosition(DeclsCursor);
4036
4037 ReadingKindTracker ReadingKind(Read_Decl, *this);
4038
4039 // Note that we are loading a declaration record.
4040 Deserializing ADecl(this);
4041
4042 auto Fail = [](const char *what, llvm::Error &&Err) {
4043 llvm::report_fatal_error(reason: Twine("ASTReader::readDeclRecord failed ") + what +
4044 ": " + toString(E: std::move(Err)));
4045 };
4046
4047 if (llvm::Error JumpFailed = DeclsCursor.JumpToBit(BitNo: Loc.Offset))
4048 Fail("jumping", std::move(JumpFailed));
4049 ASTRecordReader Record(*this, *Loc.F);
4050 ASTDeclReader Reader(*this, Record, Loc, ID, DeclLoc);
4051 Expected<unsigned> MaybeCode = DeclsCursor.ReadCode();
4052 if (!MaybeCode)
4053 Fail("reading code", MaybeCode.takeError());
4054 unsigned Code = MaybeCode.get();
4055
4056 ASTContext &Context = getContext();
4057 Decl *D = nullptr;
4058 Expected<unsigned> MaybeDeclCode = Record.readRecord(Cursor&: DeclsCursor, AbbrevID: Code);
4059 if (!MaybeDeclCode)
4060 llvm::report_fatal_error(
4061 reason: Twine("ASTReader::readDeclRecord failed reading decl code: ") +
4062 toString(E: MaybeDeclCode.takeError()));
4063
4064 switch ((DeclCode)MaybeDeclCode.get()) {
4065 case DECL_CONTEXT_LEXICAL:
4066 case DECL_CONTEXT_VISIBLE:
4067 case DECL_CONTEXT_MODULE_LOCAL_VISIBLE:
4068 case DECL_CONTEXT_TU_LOCAL_VISIBLE:
4069 case DECL_SPECIALIZATIONS:
4070 case DECL_PARTIAL_SPECIALIZATIONS:
4071 llvm_unreachable("Record cannot be de-serialized with readDeclRecord");
4072 case DECL_TYPEDEF:
4073 D = TypedefDecl::CreateDeserialized(C&: Context, ID);
4074 break;
4075 case DECL_TYPEALIAS:
4076 D = TypeAliasDecl::CreateDeserialized(C&: Context, ID);
4077 break;
4078 case DECL_ENUM:
4079 D = EnumDecl::CreateDeserialized(C&: Context, ID);
4080 break;
4081 case DECL_RECORD:
4082 D = RecordDecl::CreateDeserialized(C: Context, ID);
4083 break;
4084 case DECL_ENUM_CONSTANT:
4085 D = EnumConstantDecl::CreateDeserialized(C&: Context, ID);
4086 break;
4087 case DECL_FUNCTION:
4088 D = FunctionDecl::CreateDeserialized(C&: Context, ID);
4089 break;
4090 case DECL_LINKAGE_SPEC:
4091 D = LinkageSpecDecl::CreateDeserialized(C&: Context, ID);
4092 break;
4093 case DECL_EXPORT:
4094 D = ExportDecl::CreateDeserialized(C&: Context, ID);
4095 break;
4096 case DECL_LABEL:
4097 D = LabelDecl::CreateDeserialized(C&: Context, ID);
4098 break;
4099 case DECL_NAMESPACE:
4100 D = NamespaceDecl::CreateDeserialized(C&: Context, ID);
4101 break;
4102 case DECL_NAMESPACE_ALIAS:
4103 D = NamespaceAliasDecl::CreateDeserialized(C&: Context, ID);
4104 break;
4105 case DECL_USING:
4106 D = UsingDecl::CreateDeserialized(C&: Context, ID);
4107 break;
4108 case DECL_USING_PACK:
4109 D = UsingPackDecl::CreateDeserialized(C&: Context, ID, NumExpansions: Record.readInt());
4110 break;
4111 case DECL_USING_SHADOW:
4112 D = UsingShadowDecl::CreateDeserialized(C&: Context, ID);
4113 break;
4114 case DECL_USING_ENUM:
4115 D = UsingEnumDecl::CreateDeserialized(C&: Context, ID);
4116 break;
4117 case DECL_CONSTRUCTOR_USING_SHADOW:
4118 D = ConstructorUsingShadowDecl::CreateDeserialized(C&: Context, ID);
4119 break;
4120 case DECL_USING_DIRECTIVE:
4121 D = UsingDirectiveDecl::CreateDeserialized(C&: Context, ID);
4122 break;
4123 case DECL_UNRESOLVED_USING_VALUE:
4124 D = UnresolvedUsingValueDecl::CreateDeserialized(C&: Context, ID);
4125 break;
4126 case DECL_UNRESOLVED_USING_TYPENAME:
4127 D = UnresolvedUsingTypenameDecl::CreateDeserialized(C&: Context, ID);
4128 break;
4129 case DECL_UNRESOLVED_USING_IF_EXISTS:
4130 D = UnresolvedUsingIfExistsDecl::CreateDeserialized(Ctx&: Context, ID);
4131 break;
4132 case DECL_CXX_RECORD:
4133 D = CXXRecordDecl::CreateDeserialized(C: Context, ID);
4134 break;
4135 case DECL_CXX_DEDUCTION_GUIDE:
4136 D = CXXDeductionGuideDecl::CreateDeserialized(C&: Context, ID);
4137 break;
4138 case DECL_CXX_METHOD:
4139 D = CXXMethodDecl::CreateDeserialized(C&: Context, ID);
4140 break;
4141 case DECL_CXX_CONSTRUCTOR:
4142 D = CXXConstructorDecl::CreateDeserialized(C&: Context, ID, AllocKind: Record.readInt());
4143 break;
4144 case DECL_CXX_DESTRUCTOR:
4145 D = CXXDestructorDecl::CreateDeserialized(C&: Context, ID);
4146 break;
4147 case DECL_CXX_CONVERSION:
4148 D = CXXConversionDecl::CreateDeserialized(C&: Context, ID);
4149 break;
4150 case DECL_ACCESS_SPEC:
4151 D = AccessSpecDecl::CreateDeserialized(C&: Context, ID);
4152 break;
4153 case DECL_FRIEND:
4154 D = FriendDecl::CreateDeserialized(C&: Context, ID);
4155 break;
4156 case DECL_FRIEND_TEMPLATE:
4157 D = FriendTemplateDecl::CreateDeserialized(C&: Context, ID,
4158 /*NumTPLists=*/NumFriendTPLists: Record.readInt());
4159 break;
4160 case DECL_CLASS_TEMPLATE:
4161 D = ClassTemplateDecl::CreateDeserialized(C&: Context, ID);
4162 break;
4163 case DECL_CLASS_TEMPLATE_SPECIALIZATION:
4164 D = ClassTemplateSpecializationDecl::CreateDeserialized(C&: Context, ID);
4165 break;
4166 case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
4167 D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(C&: Context, ID);
4168 break;
4169 case DECL_VAR_TEMPLATE:
4170 D = VarTemplateDecl::CreateDeserialized(C&: Context, ID);
4171 break;
4172 case DECL_VAR_TEMPLATE_SPECIALIZATION:
4173 D = VarTemplateSpecializationDecl::CreateDeserialized(C&: Context, ID);
4174 break;
4175 case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
4176 D = VarTemplatePartialSpecializationDecl::CreateDeserialized(C&: Context, ID);
4177 break;
4178 case DECL_FUNCTION_TEMPLATE:
4179 D = FunctionTemplateDecl::CreateDeserialized(C&: Context, ID);
4180 break;
4181 case DECL_TEMPLATE_TYPE_PARM: {
4182 bool HasTypeConstraint = Record.readInt();
4183 D = TemplateTypeParmDecl::CreateDeserialized(C: Context, ID,
4184 HasTypeConstraint);
4185 break;
4186 }
4187 case DECL_NON_TYPE_TEMPLATE_PARM: {
4188 bool HasTypeConstraint = Record.readInt();
4189 D = NonTypeTemplateParmDecl::CreateDeserialized(C&: Context, ID,
4190 HasTypeConstraint);
4191 break;
4192 }
4193 case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK: {
4194 bool HasTypeConstraint = Record.readInt();
4195 D = NonTypeTemplateParmDecl::CreateDeserialized(
4196 C&: Context, ID, NumExpandedTypes: Record.readInt(), HasTypeConstraint);
4197 break;
4198 }
4199 case DECL_TEMPLATE_TEMPLATE_PARM:
4200 D = TemplateTemplateParmDecl::CreateDeserialized(C&: Context, ID);
4201 break;
4202 case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
4203 D = TemplateTemplateParmDecl::CreateDeserialized(C&: Context, ID,
4204 NumExpansions: Record.readInt());
4205 break;
4206 case DECL_TYPE_ALIAS_TEMPLATE:
4207 D = TypeAliasTemplateDecl::CreateDeserialized(C&: Context, ID);
4208 break;
4209 case DECL_CONCEPT:
4210 D = ConceptDecl::CreateDeserialized(C&: Context, ID);
4211 break;
4212 case DECL_REQUIRES_EXPR_BODY:
4213 D = RequiresExprBodyDecl::CreateDeserialized(C&: Context, ID);
4214 break;
4215 case DECL_STATIC_ASSERT:
4216 D = StaticAssertDecl::CreateDeserialized(C&: Context, ID);
4217 break;
4218 case DECL_EXPLICIT_INSTANTIATION:
4219 D = ExplicitInstantiationDecl::CreateDeserialized(C&: Context, ID,
4220 TrailingFlags: Record.readInt());
4221 break;
4222 case DECL_EXPANSION_STMT:
4223 D = CXXExpansionStmtDecl::CreateDeserialized(C&: Context, ID);
4224 break;
4225 case DECL_OBJC_METHOD:
4226 D = ObjCMethodDecl::CreateDeserialized(C&: Context, ID);
4227 break;
4228 case DECL_OBJC_INTERFACE:
4229 D = ObjCInterfaceDecl::CreateDeserialized(C: Context, ID);
4230 break;
4231 case DECL_OBJC_IVAR:
4232 D = ObjCIvarDecl::CreateDeserialized(C&: Context, ID);
4233 break;
4234 case DECL_OBJC_PROTOCOL:
4235 D = ObjCProtocolDecl::CreateDeserialized(C&: Context, ID);
4236 break;
4237 case DECL_OBJC_AT_DEFS_FIELD:
4238 D = ObjCAtDefsFieldDecl::CreateDeserialized(C&: Context, ID);
4239 break;
4240 case DECL_OBJC_CATEGORY:
4241 D = ObjCCategoryDecl::CreateDeserialized(C&: Context, ID);
4242 break;
4243 case DECL_OBJC_CATEGORY_IMPL:
4244 D = ObjCCategoryImplDecl::CreateDeserialized(C&: Context, ID);
4245 break;
4246 case DECL_OBJC_IMPLEMENTATION:
4247 D = ObjCImplementationDecl::CreateDeserialized(C&: Context, ID);
4248 break;
4249 case DECL_OBJC_COMPATIBLE_ALIAS:
4250 D = ObjCCompatibleAliasDecl::CreateDeserialized(C&: Context, ID);
4251 break;
4252 case DECL_OBJC_PROPERTY:
4253 D = ObjCPropertyDecl::CreateDeserialized(C&: Context, ID);
4254 break;
4255 case DECL_OBJC_PROPERTY_IMPL:
4256 D = ObjCPropertyImplDecl::CreateDeserialized(C&: Context, ID);
4257 break;
4258 case DECL_FIELD:
4259 D = FieldDecl::CreateDeserialized(C&: Context, ID);
4260 break;
4261 case DECL_INDIRECTFIELD:
4262 D = IndirectFieldDecl::CreateDeserialized(C&: Context, ID);
4263 break;
4264 case DECL_VAR:
4265 D = VarDecl::CreateDeserialized(C&: Context, ID);
4266 break;
4267 case DECL_IMPLICIT_PARAM:
4268 D = ImplicitParamDecl::CreateDeserialized(C&: Context, ID);
4269 break;
4270 case DECL_PARM_VAR:
4271 D = ParmVarDecl::CreateDeserialized(C&: Context, ID);
4272 break;
4273 case DECL_DECOMPOSITION:
4274 D = DecompositionDecl::CreateDeserialized(C&: Context, ID, NumBindings: Record.readInt());
4275 break;
4276 case DECL_BINDING:
4277 D = BindingDecl::CreateDeserialized(C&: Context, ID);
4278 break;
4279 case DECL_FILE_SCOPE_ASM:
4280 D = FileScopeAsmDecl::CreateDeserialized(C&: Context, ID);
4281 break;
4282 case DECL_TOP_LEVEL_STMT_DECL:
4283 D = TopLevelStmtDecl::CreateDeserialized(C&: Context, ID);
4284 break;
4285 case DECL_BLOCK:
4286 D = BlockDecl::CreateDeserialized(C&: Context, ID);
4287 break;
4288 case DECL_MS_PROPERTY:
4289 D = MSPropertyDecl::CreateDeserialized(C&: Context, ID);
4290 break;
4291 case DECL_MS_GUID:
4292 D = MSGuidDecl::CreateDeserialized(C&: Context, ID);
4293 break;
4294 case DECL_UNNAMED_GLOBAL_CONSTANT:
4295 D = UnnamedGlobalConstantDecl::CreateDeserialized(C&: Context, ID);
4296 break;
4297 case DECL_TEMPLATE_PARAM_OBJECT:
4298 D = TemplateParamObjectDecl::CreateDeserialized(C&: Context, ID);
4299 break;
4300 case DECL_OUTLINEDFUNCTION:
4301 D = OutlinedFunctionDecl::CreateDeserialized(C&: Context, ID, NumParams: Record.readInt());
4302 break;
4303 case DECL_CAPTURED:
4304 D = CapturedDecl::CreateDeserialized(C&: Context, ID, NumParams: Record.readInt());
4305 break;
4306 case DECL_CXX_BASE_SPECIFIERS:
4307 Error(Msg: "attempt to read a C++ base-specifier record as a declaration");
4308 return nullptr;
4309 case DECL_CXX_CTOR_INITIALIZERS:
4310 Error(Msg: "attempt to read a C++ ctor initializer record as a declaration");
4311 return nullptr;
4312 case DECL_IMPORT:
4313 // Note: last entry of the ImportDecl record is the number of stored source
4314 // locations.
4315 D = ImportDecl::CreateDeserialized(C&: Context, ID, NumLocations: Record.back());
4316 break;
4317 case DECL_OMP_THREADPRIVATE: {
4318 Record.skipInts(N: 1);
4319 unsigned NumChildren = Record.readInt();
4320 Record.skipInts(N: 1);
4321 D = OMPThreadPrivateDecl::CreateDeserialized(C&: Context, ID, N: NumChildren);
4322 break;
4323 }
4324 case DECL_OMP_ALLOCATE: {
4325 unsigned NumClauses = Record.readInt();
4326 unsigned NumVars = Record.readInt();
4327 Record.skipInts(N: 1);
4328 D = OMPAllocateDecl::CreateDeserialized(C&: Context, ID, NVars: NumVars, NClauses: NumClauses);
4329 break;
4330 }
4331 case DECL_OMP_REQUIRES: {
4332 unsigned NumClauses = Record.readInt();
4333 Record.skipInts(N: 2);
4334 D = OMPRequiresDecl::CreateDeserialized(C&: Context, ID, N: NumClauses);
4335 break;
4336 }
4337 case DECL_OMP_DECLARE_REDUCTION:
4338 D = OMPDeclareReductionDecl::CreateDeserialized(C&: Context, ID);
4339 break;
4340 case DECL_OMP_DECLARE_MAPPER: {
4341 unsigned NumClauses = Record.readInt();
4342 Record.skipInts(N: 2);
4343 D = OMPDeclareMapperDecl::CreateDeserialized(C&: Context, ID, N: NumClauses);
4344 break;
4345 }
4346 case DECL_OMP_CAPTUREDEXPR:
4347 D = OMPCapturedExprDecl::CreateDeserialized(C&: Context, ID);
4348 break;
4349 case DECL_PRAGMA_COMMENT:
4350 D = PragmaCommentDecl::CreateDeserialized(C&: Context, ID, ArgSize: Record.readInt());
4351 break;
4352 case DECL_PRAGMA_DETECT_MISMATCH:
4353 D = PragmaDetectMismatchDecl::CreateDeserialized(C&: Context, ID,
4354 NameValueSize: Record.readInt());
4355 break;
4356 case DECL_EMPTY:
4357 D = EmptyDecl::CreateDeserialized(C&: Context, ID);
4358 break;
4359 case DECL_LIFETIME_EXTENDED_TEMPORARY:
4360 D = LifetimeExtendedTemporaryDecl::CreateDeserialized(C&: Context, ID);
4361 break;
4362 case DECL_OBJC_TYPE_PARAM:
4363 D = ObjCTypeParamDecl::CreateDeserialized(ctx&: Context, ID);
4364 break;
4365 case DECL_HLSL_BUFFER:
4366 D = HLSLBufferDecl::CreateDeserialized(C&: Context, ID);
4367 break;
4368 case DECL_IMPLICIT_CONCEPT_SPECIALIZATION:
4369 D = ImplicitConceptSpecializationDecl::CreateDeserialized(C: Context, ID,
4370 NumTemplateArgs: Record.readInt());
4371 break;
4372 case DECL_OPENACC_DECLARE:
4373 D = OpenACCDeclareDecl::CreateDeserialized(Ctx&: Context, ID, NumClauses: Record.readInt());
4374 break;
4375 case DECL_OPENACC_ROUTINE:
4376 D = OpenACCRoutineDecl::CreateDeserialized(Ctx&: Context, ID, NumClauses: Record.readInt());
4377 break;
4378 }
4379
4380 assert(D && "Unknown declaration reading AST file");
4381 LoadedDecl(Index: translateGlobalDeclIDToIndex(ID), D);
4382 // Set the DeclContext before doing any deserialization, to make sure internal
4383 // calls to Decl::getASTContext() by Decl's methods will find the
4384 // TranslationUnitDecl without crashing.
4385 D->setDeclContext(Context.getTranslationUnitDecl());
4386
4387 // Reading some declarations can result in deep recursion.
4388 runWithSufficientStackSpace(Loc: DeclLoc, Fn: [&] { Reader.Visit(D); });
4389
4390 // If this declaration is also a declaration context, get the
4391 // offsets for its tables of lexical and visible declarations.
4392 if (auto *DC = dyn_cast<DeclContext>(Val: D)) {
4393 LookupBlockOffsets Offsets;
4394
4395 Reader.VisitDeclContext(DC, Offsets);
4396
4397 // Get the lexical and visible block for the delayed namespace.
4398 // It is sufficient to judge if ID is in DelayedNamespaceOffsetMap.
4399 // But it may be more efficient to filter the other cases.
4400 if (!Offsets && isa<NamespaceDecl>(Val: D))
4401 if (auto Iter = DelayedNamespaceOffsetMap.find(Val: ID);
4402 Iter != DelayedNamespaceOffsetMap.end())
4403 Offsets = Iter->second;
4404
4405 if (Offsets.VisibleOffset &&
4406 ReadVisibleDeclContextStorage(
4407 M&: *Loc.F, Cursor&: DeclsCursor, Offset: Offsets.VisibleOffset, ID,
4408 VisibleKind: VisibleDeclContextStorageKind::GenerallyVisible))
4409 return nullptr;
4410 if (Offsets.ModuleLocalOffset &&
4411 ReadVisibleDeclContextStorage(
4412 M&: *Loc.F, Cursor&: DeclsCursor, Offset: Offsets.ModuleLocalOffset, ID,
4413 VisibleKind: VisibleDeclContextStorageKind::ModuleLocalVisible))
4414 return nullptr;
4415 if (Offsets.TULocalOffset &&
4416 ReadVisibleDeclContextStorage(
4417 M&: *Loc.F, Cursor&: DeclsCursor, Offset: Offsets.TULocalOffset, ID,
4418 VisibleKind: VisibleDeclContextStorageKind::TULocalVisible))
4419 return nullptr;
4420
4421 if (Offsets.LexicalOffset &&
4422 ReadLexicalDeclContextStorage(M&: *Loc.F, Cursor&: DeclsCursor,
4423 Offset: Offsets.LexicalOffset, DC))
4424 return nullptr;
4425 }
4426 assert(Record.getIdx() == Record.size());
4427
4428 // Load any relevant update records.
4429 PendingUpdateRecords.push_back(
4430 Elt: PendingUpdateRecord(ID, D, /*JustLoaded=*/true));
4431
4432 // Load the categories after recursive loading is finished.
4433 if (auto *Class = dyn_cast<ObjCInterfaceDecl>(Val: D))
4434 // If we already have a definition when deserializing the ObjCInterfaceDecl,
4435 // we put the Decl in PendingDefinitions so we can pull the categories here.
4436 if (Class->isThisDeclarationADefinition() ||
4437 PendingDefinitions.count(Ptr: Class))
4438 loadObjCCategories(ID, D: Class);
4439
4440 // If we have deserialized a declaration that has a definition the
4441 // AST consumer might need to know about, queue it.
4442 // We don't pass it to the consumer immediately because we may be in recursive
4443 // loading, and some declarations may still be initializing.
4444 PotentiallyInterestingDecls.push_back(x: D);
4445
4446 return D;
4447}
4448
4449void ASTReader::PassInterestingDeclsToConsumer() {
4450 assert(Consumer);
4451
4452 if (!CanPassDeclsToConsumer)
4453 return;
4454
4455 // Guard variable to avoid recursively redoing the process of passing
4456 // decls to consumer.
4457 SaveAndRestore GuardPassingDeclsToConsumer(CanPassDeclsToConsumer,
4458 /*NewValue=*/false);
4459
4460 // Ensure that we've loaded all potentially-interesting declarations
4461 // that need to be eagerly loaded.
4462 for (auto ID : EagerlyDeserializedDecls)
4463 GetDecl(ID);
4464 EagerlyDeserializedDecls.clear();
4465
4466 auto ConsumingPotentialInterestingDecls = [this]() {
4467 while (!PotentiallyInterestingDecls.empty()) {
4468 Decl *D = PotentiallyInterestingDecls.front();
4469 PotentiallyInterestingDecls.pop_front();
4470 if (isConsumerInterestedIn(D))
4471 PassInterestingDeclToConsumer(D);
4472 }
4473 };
4474 std::deque<Decl *> MaybeInterestingDecls =
4475 std::move(PotentiallyInterestingDecls);
4476 PotentiallyInterestingDecls.clear();
4477 assert(PotentiallyInterestingDecls.empty());
4478 while (!MaybeInterestingDecls.empty()) {
4479 Decl *D = MaybeInterestingDecls.front();
4480 MaybeInterestingDecls.pop_front();
4481 // Since we load the variable's initializers lazily, it'd be problematic
4482 // if the initializers dependent on each other. So here we try to load the
4483 // initializers of static variables to make sure they are passed to code
4484 // generator by order. If we read anything interesting, we would consume
4485 // that before emitting the current declaration.
4486 if (auto *VD = dyn_cast<VarDecl>(Val: D);
4487 VD && VD->isFileVarDecl() && !VD->isExternallyVisible())
4488 VD->getInit();
4489 ConsumingPotentialInterestingDecls();
4490 if (isConsumerInterestedIn(D))
4491 PassInterestingDeclToConsumer(D);
4492 }
4493
4494 // If we add any new potential interesting decl in the last call, consume it.
4495 ConsumingPotentialInterestingDecls();
4496
4497 for (GlobalDeclID ID : VTablesToEmit) {
4498 auto *RD = cast<CXXRecordDecl>(Val: GetDecl(ID));
4499 assert(!RD->shouldEmitInExternalSource());
4500 PassVTableToConsumer(RD);
4501 }
4502 VTablesToEmit.clear();
4503}
4504
4505void ASTReader::loadDeclUpdateRecords(PendingUpdateRecord &Record) {
4506 // The declaration may have been modified by files later in the chain.
4507 // If this is the case, read the record containing the updates from each file
4508 // and pass it to ASTDeclReader to make the modifications.
4509 GlobalDeclID ID = Record.ID;
4510 Decl *D = Record.D;
4511 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
4512 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(Val: ID);
4513
4514 if (UpdI != DeclUpdateOffsets.end()) {
4515 auto UpdateOffsets = std::move(UpdI->second);
4516 DeclUpdateOffsets.erase(I: UpdI);
4517
4518 // Check if this decl was interesting to the consumer. If we just loaded
4519 // the declaration, then we know it was interesting and we skip the call
4520 // to isConsumerInterestedIn because it is unsafe to call in the
4521 // current ASTReader state.
4522 bool WasInteresting = Record.JustLoaded || isConsumerInterestedIn(D);
4523 for (auto &FileAndOffset : UpdateOffsets) {
4524 ModuleFile *F = FileAndOffset.first;
4525 uint64_t Offset = FileAndOffset.second;
4526 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
4527 SavedStreamPosition SavedPosition(Cursor);
4528 if (llvm::Error JumpFailed = Cursor.JumpToBit(BitNo: Offset))
4529 // FIXME don't do a fatal error.
4530 llvm::report_fatal_error(
4531 reason: Twine("ASTReader::loadDeclUpdateRecords failed jumping: ") +
4532 toString(E: std::move(JumpFailed)));
4533 Expected<unsigned> MaybeCode = Cursor.ReadCode();
4534 if (!MaybeCode)
4535 llvm::report_fatal_error(
4536 reason: Twine("ASTReader::loadDeclUpdateRecords failed reading code: ") +
4537 toString(E: MaybeCode.takeError()));
4538 unsigned Code = MaybeCode.get();
4539 ASTRecordReader Record(*this, *F);
4540 if (Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, AbbrevID: Code))
4541 assert(MaybeRecCode.get() == DECL_UPDATES &&
4542 "Expected DECL_UPDATES record!");
4543 else
4544 llvm::report_fatal_error(
4545 reason: Twine("ASTReader::loadDeclUpdateRecords failed reading rec code: ") +
4546 toString(E: MaybeCode.takeError()));
4547
4548 ASTDeclReader Reader(*this, Record, RecordLocation(F, Offset), ID,
4549 SourceLocation());
4550 Reader.UpdateDecl(D);
4551
4552 // We might have made this declaration interesting. If so, remember that
4553 // we need to hand it off to the consumer.
4554 if (!WasInteresting && isConsumerInterestedIn(D)) {
4555 PotentiallyInterestingDecls.push_back(x: D);
4556 WasInteresting = true;
4557 }
4558 }
4559 }
4560
4561 // Load the pending visible updates for this decl context, if it has any.
4562 if (auto I = PendingVisibleUpdates.find(Val: ID);
4563 I != PendingVisibleUpdates.end()) {
4564 auto VisibleUpdates = std::move(I->second);
4565 PendingVisibleUpdates.erase(I);
4566
4567 auto *DC = cast<DeclContext>(Val: D)->getPrimaryContext();
4568 for (const auto &Update : VisibleUpdates)
4569 Lookups[DC].Table.add(
4570 File: Update.Mod, Data: Update.Data,
4571 InfoObj: reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));
4572 DC->setHasExternalVisibleStorage(true);
4573 }
4574
4575 if (auto I = PendingModuleLocalVisibleUpdates.find(Val: ID);
4576 I != PendingModuleLocalVisibleUpdates.end()) {
4577 auto ModuleLocalVisibleUpdates = std::move(I->second);
4578 PendingModuleLocalVisibleUpdates.erase(I);
4579
4580 auto *DC = cast<DeclContext>(Val: D)->getPrimaryContext();
4581 for (const auto &Update : ModuleLocalVisibleUpdates)
4582 ModuleLocalLookups[DC].Table.add(
4583 File: Update.Mod, Data: Update.Data,
4584 InfoObj: reader::ModuleLocalNameLookupTrait(*this, *Update.Mod));
4585 // NOTE: Can we optimize the case that the data being loaded
4586 // is not related to current module?
4587 DC->setHasExternalVisibleStorage(true);
4588 }
4589
4590 if (auto I = TULocalUpdates.find(Val: ID); I != TULocalUpdates.end()) {
4591 auto Updates = std::move(I->second);
4592 TULocalUpdates.erase(I);
4593
4594 auto *DC = cast<DeclContext>(Val: D)->getPrimaryContext();
4595 for (const auto &Update : Updates)
4596 TULocalLookups[DC].Table.add(
4597 File: Update.Mod, Data: Update.Data,
4598 InfoObj: reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));
4599 DC->setHasExternalVisibleStorage(true);
4600 }
4601
4602 // Load any pending related decls.
4603 if (D->isCanonicalDecl()) {
4604 if (auto IT = RelatedDeclsMap.find(Val: ID); IT != RelatedDeclsMap.end()) {
4605 for (auto LID : IT->second)
4606 GetDecl(ID: LID);
4607 RelatedDeclsMap.erase(I: IT);
4608 }
4609 }
4610
4611 // Load the pending specializations update for this decl, if it has any.
4612 if (auto I = PendingSpecializationsUpdates.find(Val: ID);
4613 I != PendingSpecializationsUpdates.end()) {
4614 auto SpecializationUpdates = std::move(I->second);
4615 PendingSpecializationsUpdates.erase(I);
4616
4617 for (const auto &Update : SpecializationUpdates)
4618 AddSpecializations(D, Data: Update.Data, M&: *Update.Mod, /*IsPartial=*/false);
4619 }
4620
4621 // Load the pending specializations update for this decl, if it has any.
4622 if (auto I = PendingPartialSpecializationsUpdates.find(Val: ID);
4623 I != PendingPartialSpecializationsUpdates.end()) {
4624 auto SpecializationUpdates = std::move(I->second);
4625 PendingPartialSpecializationsUpdates.erase(I);
4626
4627 for (const auto &Update : SpecializationUpdates)
4628 AddSpecializations(D, Data: Update.Data, M&: *Update.Mod, /*IsPartial=*/true);
4629 }
4630}
4631
4632void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {
4633 Decl *CanonDecl = FirstLocal->getCanonicalDecl();
4634
4635 Decl *MostRecent = ASTDeclReader::getMostRecentDecl(D: CanonDecl);
4636 if (!MostRecent)
4637 MostRecent = CanonDecl;
4638 if (FirstLocal != CanonDecl) {
4639 // Attach FirstLocal to the end of the decl chain.
4640 ASTDeclReader::attachPreviousDecl(Reader&: *this, D: FirstLocal, Previous: MostRecent, Canon: CanonDecl);
4641 MostRecent = FirstLocal;
4642 }
4643
4644 if (!LocalOffset) {
4645 ASTDeclReader::attachLatestDecl(D: CanonDecl, Latest: MostRecent);
4646 return;
4647 }
4648
4649 // Load the list of other redeclarations from this module file.
4650 ModuleFile *M = getOwningModuleFile(D: FirstLocal);
4651 assert(M && "imported decl from no module file");
4652
4653 llvm::BitstreamCursor &Cursor = M->DeclsCursor;
4654 SavedStreamPosition SavedPosition(Cursor);
4655 if (llvm::Error JumpFailed = Cursor.JumpToBit(BitNo: LocalOffset))
4656 llvm::report_fatal_error(
4657 reason: Twine("ASTReader::loadPendingDeclChain failed jumping: ") +
4658 toString(E: std::move(JumpFailed)));
4659
4660 RecordData Record;
4661 Expected<unsigned> MaybeCode = Cursor.ReadCode();
4662 if (!MaybeCode)
4663 llvm::report_fatal_error(
4664 reason: Twine("ASTReader::loadPendingDeclChain failed reading code: ") +
4665 toString(E: MaybeCode.takeError()));
4666 unsigned Code = MaybeCode.get();
4667 if (Expected<unsigned> MaybeRecCode = Cursor.readRecord(AbbrevID: Code, Vals&: Record))
4668 assert(MaybeRecCode.get() == LOCAL_REDECLARATIONS &&
4669 "expected LOCAL_REDECLARATIONS record!");
4670 else
4671 llvm::report_fatal_error(
4672 reason: Twine("ASTReader::loadPendingDeclChain failed reading rec code: ") +
4673 toString(E: MaybeCode.takeError()));
4674
4675 // FIXME: We have several different dispatches on decl kind here; maybe
4676 // we should instead generate one loop per kind and dispatch up-front?
4677 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
4678 unsigned Idx = N - I - 1;
4679 auto *D = ReadDecl(F&: *M, R: Record, I&: Idx);
4680 ASTDeclReader::attachPreviousDecl(Reader&: *this, D, Previous: MostRecent, Canon: CanonDecl);
4681 MostRecent = D;
4682 }
4683 ASTDeclReader::attachLatestDecl(D: CanonDecl, Latest: MostRecent);
4684}
4685
4686namespace {
4687
4688 /// Given an ObjC interface, goes through the modules and links to the
4689 /// interface all the categories for it.
4690 class ObjCCategoriesVisitor {
4691 ASTReader &Reader;
4692 ObjCInterfaceDecl *Interface;
4693 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
4694 ObjCCategoryDecl *Tail = nullptr;
4695 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
4696 GlobalDeclID InterfaceID;
4697 unsigned PreviousGeneration;
4698
4699 void add(ObjCCategoryDecl *Cat) {
4700 // Only process each category once.
4701 if (!Deserialized.erase(Ptr: Cat))
4702 return;
4703
4704 // Check for duplicate categories.
4705 if (Cat->getDeclName()) {
4706 ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
4707 if (Existing && Reader.getOwningModuleFile(D: Existing) !=
4708 Reader.getOwningModuleFile(D: Cat)) {
4709 StructuralEquivalenceContext::NonEquivalentDeclSet NonEquivalentDecls;
4710 StructuralEquivalenceContext Ctx(
4711 Reader.getContext().getLangOpts(), Cat->getASTContext(),
4712 Existing->getASTContext(), NonEquivalentDecls,
4713 StructuralEquivalenceKind::Default,
4714 /*StrictTypeSpelling=*/false,
4715 /*Complain=*/false,
4716 /*ErrorOnTagTypeMismatch=*/true);
4717 if (!Ctx.IsEquivalent(D1: Cat, D2: Existing)) {
4718 // Warn only if the categories with the same name are different.
4719 Reader.Diag(Loc: Cat->getLocation(), DiagID: diag::warn_dup_category_def)
4720 << Interface->getDeclName() << Cat->getDeclName();
4721 Reader.Diag(Loc: Existing->getLocation(),
4722 DiagID: diag::note_previous_definition);
4723 }
4724 } else if (!Existing) {
4725 // Record this category.
4726 Existing = Cat;
4727 }
4728 }
4729
4730 // Add this category to the end of the chain.
4731 if (Tail)
4732 ASTDeclReader::setNextObjCCategory(Cat: Tail, Next: Cat);
4733 else
4734 Interface->setCategoryListRaw(Cat);
4735 Tail = Cat;
4736 }
4737
4738 public:
4739 ObjCCategoriesVisitor(
4740 ASTReader &Reader, ObjCInterfaceDecl *Interface,
4741 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
4742 GlobalDeclID InterfaceID, unsigned PreviousGeneration)
4743 : Reader(Reader), Interface(Interface), Deserialized(Deserialized),
4744 InterfaceID(InterfaceID), PreviousGeneration(PreviousGeneration) {
4745 // Populate the name -> category map with the set of known categories.
4746 for (auto *Cat : Interface->known_categories()) {
4747 if (Cat->getDeclName())
4748 NameCategoryMap[Cat->getDeclName()] = Cat;
4749
4750 // Keep track of the tail of the category list.
4751 Tail = Cat;
4752 }
4753 }
4754
4755 bool operator()(ModuleFile &M) {
4756 // If we've loaded all of the category information we care about from
4757 // this module file, we're done.
4758 if (M.Generation <= PreviousGeneration)
4759 return true;
4760
4761 // Map global ID of the definition down to the local ID used in this
4762 // module file. If there is no such mapping, we'll find nothing here
4763 // (or in any module it imports).
4764 LocalDeclID LocalID =
4765 Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID: InterfaceID);
4766 if (LocalID.isInvalid())
4767 return true;
4768
4769 // Perform a binary search to find the local redeclarations for this
4770 // declaration (if any).
4771 const ObjCCategoriesInfo Compare = {LocalID, 0};
4772 const ObjCCategoriesInfo *Result = std::lower_bound(
4773 first: M.ObjCCategoriesMap,
4774 last: M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap, val: Compare);
4775 if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
4776 LocalID != Result->getDefinitionID()) {
4777 // We didn't find anything. If the class definition is in this module
4778 // file, then the module files it depends on cannot have any categories,
4779 // so suppress further lookup.
4780 return Reader.isDeclIDFromModule(ID: InterfaceID, M);
4781 }
4782
4783 // We found something. Dig out all of the categories.
4784 unsigned Offset = Result->Offset;
4785 unsigned N = M.ObjCCategories[Offset];
4786 M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
4787 for (unsigned I = 0; I != N; ++I)
4788 add(Cat: Reader.ReadDeclAs<ObjCCategoryDecl>(F&: M, R: M.ObjCCategories, I&: Offset));
4789 return true;
4790 }
4791 };
4792
4793} // namespace
4794
4795void ASTReader::loadObjCCategories(GlobalDeclID ID, ObjCInterfaceDecl *D,
4796 unsigned PreviousGeneration) {
4797 ObjCCategoriesVisitor Visitor(*this, D, CategoriesDeserialized, ID,
4798 PreviousGeneration);
4799 ModuleMgr.visit(Visitor);
4800}
4801
4802template<typename DeclT, typename Fn>
4803static void forAllLaterRedecls(DeclT *D, Fn F) {
4804 F(D);
4805
4806 // Check whether we've already merged D into its redeclaration chain.
4807 // MostRecent may or may not be nullptr if D has not been merged. If
4808 // not, walk the merged redecl chain and see if it's there.
4809 auto *MostRecent = D->getMostRecentDecl();
4810 bool Found = false;
4811 for (auto *Redecl = MostRecent; Redecl && !Found;
4812 Redecl = Redecl->getPreviousDecl())
4813 Found = (Redecl == D);
4814
4815 // If this declaration is merged, apply the functor to all later decls.
4816 if (Found) {
4817 for (auto *Redecl = MostRecent; Redecl != D;
4818 Redecl = Redecl->getPreviousDecl())
4819 F(Redecl);
4820 }
4821}
4822
4823void ASTDeclReader::UpdateDecl(Decl *D) {
4824 while (Record.getIdx() < Record.size()) {
4825 switch ((DeclUpdateKind)Record.readInt()) {
4826 case DeclUpdateKind::CXXAddedImplicitMember: {
4827 auto *RD = cast<CXXRecordDecl>(Val: D);
4828 Decl *MD = Record.readDecl();
4829 assert(MD && "couldn't read decl from update record");
4830 Reader.PendingAddedClassMembers.push_back(Elt: {RD, MD});
4831 break;
4832 }
4833
4834 case DeclUpdateKind::CXXAddedAnonymousNamespace: {
4835 auto *Anon = readDeclAs<NamespaceDecl>();
4836
4837 // Each module has its own anonymous namespace, which is disjoint from
4838 // any other module's anonymous namespaces, so don't attach the anonymous
4839 // namespace at all.
4840 if (!Record.isModule()) {
4841 if (auto *TU = dyn_cast<TranslationUnitDecl>(Val: D))
4842 TU->setAnonymousNamespace(Anon);
4843 else
4844 cast<NamespaceDecl>(Val: D)->setAnonymousNamespace(Anon);
4845 }
4846 break;
4847 }
4848
4849 case DeclUpdateKind::CXXAddedVarDefinition: {
4850 auto *VD = cast<VarDecl>(Val: D);
4851 VD->NonParmVarDeclBits.IsInline = Record.readInt();
4852 VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
4853 ReadVarDeclInit(VD);
4854 break;
4855 }
4856
4857 case DeclUpdateKind::CXXPointOfInstantiation: {
4858 SourceLocation POI = Record.readSourceLocation();
4859 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Val: D)) {
4860 VTSD->setPointOfInstantiation(POI);
4861 } else if (auto *VD = dyn_cast<VarDecl>(Val: D)) {
4862 MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo();
4863 assert(MSInfo && "No member specialization information");
4864 MSInfo->setPointOfInstantiation(POI);
4865 } else {
4866 auto *FD = cast<FunctionDecl>(Val: D);
4867 if (auto *FTSInfo = dyn_cast<FunctionTemplateSpecializationInfo *>(
4868 Val&: FD->TemplateOrSpecialization))
4869 FTSInfo->setPointOfInstantiation(POI);
4870 else
4871 cast<MemberSpecializationInfo *>(Val&: FD->TemplateOrSpecialization)
4872 ->setPointOfInstantiation(POI);
4873 }
4874 break;
4875 }
4876
4877 case DeclUpdateKind::CXXInstantiatedDefaultArgument: {
4878 auto *Param = cast<ParmVarDecl>(Val: D);
4879
4880 // We have to read the default argument regardless of whether we use it
4881 // so that hypothetical further update records aren't messed up.
4882 // TODO: Add a function to skip over the next expr record.
4883 auto *DefaultArg = Record.readExpr();
4884
4885 // Only apply the update if the parameter still has an uninstantiated
4886 // default argument.
4887 if (Param->hasUninstantiatedDefaultArg())
4888 Param->setDefaultArg(DefaultArg);
4889 break;
4890 }
4891
4892 case DeclUpdateKind::CXXInstantiatedDefaultMemberInitializer: {
4893 auto *FD = cast<FieldDecl>(Val: D);
4894 auto *DefaultInit = Record.readExpr();
4895
4896 // Only apply the update if the field still has an uninstantiated
4897 // default member initializer.
4898 if (FD->hasInClassInitializer() && !FD->hasNonNullInClassInitializer()) {
4899 if (DefaultInit)
4900 FD->setInClassInitializer(DefaultInit);
4901 else
4902 // Instantiation failed. We can get here if we serialized an AST for
4903 // an invalid program.
4904 FD->removeInClassInitializer();
4905 }
4906 break;
4907 }
4908
4909 case DeclUpdateKind::CXXAddedFunctionDefinition: {
4910 auto *FD = cast<FunctionDecl>(Val: D);
4911 if (Reader.PendingBodies[FD]) {
4912 // FIXME: Maybe check for ODR violations.
4913 // It's safe to stop now because this update record is always last.
4914 return;
4915 }
4916
4917 if (Record.readInt()) {
4918 // Maintain AST consistency: any later redeclarations of this function
4919 // are inline if this one is. (We might have merged another declaration
4920 // into this one.)
4921 forAllLaterRedecls(D: FD, F: [](FunctionDecl *FD) {
4922 FD->setImplicitlyInline();
4923 });
4924 }
4925 FD->setInnerLocStart(readSourceLocation());
4926 ReadFunctionDefinition(FD);
4927 assert(Record.getIdx() == Record.size() && "lazy body must be last");
4928 break;
4929 }
4930
4931 case DeclUpdateKind::CXXInstantiatedClassDefinition: {
4932 auto *RD = cast<CXXRecordDecl>(Val: D);
4933 auto *OldDD = RD->getCanonicalDecl()->DefinitionData;
4934 bool HadRealDefinition =
4935 OldDD && (OldDD->Definition != RD ||
4936 !Reader.PendingFakeDefinitionData.count(Val: OldDD));
4937 RD->setParamDestroyedInCallee(Record.readInt());
4938 RD->setArgPassingRestrictions(
4939 static_cast<RecordArgPassingKind>(Record.readInt()));
4940 ReadCXXRecordDefinition(D: RD, /*Update*/true);
4941
4942 // Visible update is handled separately.
4943 uint64_t LexicalOffset = ReadLocalOffset();
4944 if (!HadRealDefinition && LexicalOffset) {
4945 Record.readLexicalDeclContextStorage(Offset: LexicalOffset, DC: RD);
4946 Reader.PendingFakeDefinitionData.erase(Val: OldDD);
4947 }
4948
4949 auto TSK = (TemplateSpecializationKind)Record.readInt();
4950 SourceLocation POI = readSourceLocation();
4951 if (MemberSpecializationInfo *MSInfo =
4952 RD->getMemberSpecializationInfo()) {
4953 MSInfo->setTemplateSpecializationKind(TSK);
4954 MSInfo->setPointOfInstantiation(POI);
4955 } else {
4956 auto *Spec = cast<ClassTemplateSpecializationDecl>(Val: RD);
4957 Spec->setTemplateSpecializationKind(TSK);
4958 Spec->setPointOfInstantiation(POI);
4959
4960 if (Record.readInt()) {
4961 auto *PartialSpec =
4962 readDeclAs<ClassTemplatePartialSpecializationDecl>();
4963 SmallVector<TemplateArgument, 8> TemplArgs;
4964 Record.readTemplateArgumentList(TemplArgs);
4965 auto *TemplArgList = TemplateArgumentList::CreateCopy(
4966 Context&: Reader.getContext(), Args: TemplArgs);
4967
4968 // FIXME: If we already have a partial specialization set,
4969 // check that it matches.
4970 if (!isa<ClassTemplatePartialSpecializationDecl *>(
4971 Val: Spec->getSpecializedTemplateOrPartial()))
4972 Spec->setInstantiationOf(PartialSpec, TemplateArgs: TemplArgList);
4973 }
4974 }
4975
4976 RD->setTagKind(static_cast<TagTypeKind>(Record.readInt()));
4977 RD->setLocation(readSourceLocation());
4978 RD->setLocStart(readSourceLocation());
4979 RD->setBraceRange(readSourceRange());
4980
4981 if (Record.readInt()) {
4982 AttrVec Attrs;
4983 Record.readAttributes(Attrs);
4984 // If the declaration already has attributes, we assume that some other
4985 // AST file already loaded them.
4986 if (!D->hasAttrs())
4987 D->setAttrsImpl(Attrs, Ctx&: Reader.getContext());
4988 }
4989 break;
4990 }
4991
4992 case DeclUpdateKind::CXXResolvedDtorDelete: {
4993 // Set the 'operator delete' directly to avoid emitting another update
4994 // record.
4995 CXXDestructorDecl *Canon = cast<CXXDestructorDecl>(Val: D->getCanonicalDecl());
4996 ASTContext &C = Reader.getContext();
4997 auto *Del = readDeclAs<FunctionDecl>();
4998 auto *ThisArg = Record.readExpr();
4999 auto *Dtor = cast<CXXDestructorDecl>(Val: D);
5000 // FIXME: Check consistency if we have an old and new operator delete.
5001 if (!C.dtorHasOperatorDelete(Dtor,
5002 K: ASTContext::OperatorDeleteKind::Regular)) {
5003 C.addOperatorDeleteForVDtor(Dtor, OperatorDelete: Del,
5004 K: ASTContext::OperatorDeleteKind::Regular);
5005 Canon->OperatorDeleteThisArg = ThisArg;
5006 }
5007 break;
5008 }
5009
5010 case DeclUpdateKind::CXXResolvedDtorGlobDelete: {
5011 auto *Del = readDeclAs<FunctionDecl>();
5012 auto *Dtor = cast<CXXDestructorDecl>(Val: D);
5013 ASTContext &C = Reader.getContext();
5014 if (!C.dtorHasOperatorDelete(
5015 Dtor, K: ASTContext::OperatorDeleteKind::GlobalRegular))
5016 C.addOperatorDeleteForVDtor(
5017 Dtor, OperatorDelete: Del, K: ASTContext::OperatorDeleteKind::GlobalRegular);
5018 break;
5019 }
5020 case DeclUpdateKind::CXXResolvedDtorArrayDelete: {
5021 auto *Del = readDeclAs<FunctionDecl>();
5022 auto *Dtor = cast<CXXDestructorDecl>(Val: D);
5023 ASTContext &C = Reader.getContext();
5024 if (!C.dtorHasOperatorDelete(Dtor, K: ASTContext::OperatorDeleteKind::Array))
5025 C.addOperatorDeleteForVDtor(Dtor, OperatorDelete: Del,
5026 K: ASTContext::OperatorDeleteKind::Array);
5027 break;
5028 }
5029 case DeclUpdateKind::CXXResolvedDtorGlobArrayDelete: {
5030 auto *Del = readDeclAs<FunctionDecl>();
5031 auto *Dtor = cast<CXXDestructorDecl>(Val: D);
5032 ASTContext &C = Reader.getContext();
5033 if (!C.dtorHasOperatorDelete(Dtor,
5034 K: ASTContext::OperatorDeleteKind::ArrayGlobal))
5035 C.addOperatorDeleteForVDtor(
5036 Dtor, OperatorDelete: Del, K: ASTContext::OperatorDeleteKind::ArrayGlobal);
5037 break;
5038 }
5039
5040 case DeclUpdateKind::CXXResolvedExceptionSpec: {
5041 SmallVector<QualType, 8> ExceptionStorage;
5042 auto ESI = Record.readExceptionSpecInfo(buffer&: ExceptionStorage);
5043
5044 // Update this declaration's exception specification, if needed.
5045 auto *FD = cast<FunctionDecl>(Val: D);
5046 auto *FPT = FD->getType()->castAs<FunctionProtoType>();
5047 // FIXME: If the exception specification is already present, check that it
5048 // matches.
5049 if (isUnresolvedExceptionSpec(ESpecType: FPT->getExceptionSpecType())) {
5050 FD->setType(Reader.getContext().getFunctionType(
5051 ResultTy: FPT->getReturnType(), Args: FPT->getParamTypes(),
5052 EPI: FPT->getExtProtoInfo().withExceptionSpec(ESI)));
5053
5054 // When we get to the end of deserializing, see if there are other decls
5055 // that we need to propagate this exception specification onto.
5056 Reader.PendingExceptionSpecUpdates.insert(
5057 KV: std::make_pair(x: FD->getCanonicalDecl(), y&: FD));
5058 }
5059 break;
5060 }
5061
5062 case DeclUpdateKind::CXXDeducedReturnType: {
5063 auto *FD = cast<FunctionDecl>(Val: D);
5064 QualType DeducedResultType = Record.readType();
5065 Reader.PendingDeducedTypeUpdates.insert(
5066 KV: {FD->getCanonicalDecl(), DeducedResultType});
5067 break;
5068 }
5069
5070 case DeclUpdateKind::DeclMarkedUsed:
5071 // Maintain AST consistency: any later redeclarations are used too.
5072 D->markUsed(C&: Reader.getContext());
5073 break;
5074
5075 case DeclUpdateKind::ManglingNumber:
5076 Reader.getContext().setManglingNumber(ND: cast<NamedDecl>(Val: D),
5077 Number: Record.readInt());
5078 break;
5079
5080 case DeclUpdateKind::StaticLocalNumber:
5081 Reader.getContext().setStaticLocalNumber(VD: cast<VarDecl>(Val: D),
5082 Number: Record.readInt());
5083 break;
5084
5085 case DeclUpdateKind::DeclMarkedOpenMPThreadPrivate:
5086 D->addAttr(A: OMPThreadPrivateDeclAttr::CreateImplicit(Ctx&: Reader.getContext(),
5087 Range: readSourceRange()));
5088 break;
5089
5090 case DeclUpdateKind::DeclMarkedOpenMPAllocate: {
5091 auto AllocatorKind =
5092 static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(Record.readInt());
5093 Expr *Allocator = Record.readExpr();
5094 Expr *Alignment = Record.readExpr();
5095 SourceRange SR = readSourceRange();
5096 D->addAttr(A: OMPAllocateDeclAttr::CreateImplicit(
5097 Ctx&: Reader.getContext(), AllocatorType: AllocatorKind, Allocator, Alignment, Range: SR));
5098 break;
5099 }
5100
5101 case DeclUpdateKind::DeclMarkedOpenMPIndirectCall:
5102 D->addAttr(A: OMPTargetIndirectCallAttr::CreateImplicit(Ctx&: Reader.getContext(),
5103 Range: readSourceRange()));
5104 break;
5105
5106 case DeclUpdateKind::DeclExported: {
5107 unsigned SubmoduleID = readSubmoduleID();
5108 auto *Exported = cast<NamedDecl>(Val: D);
5109 Module *Owner = SubmoduleID ? Reader.getSubmodule(GlobalID: SubmoduleID) : nullptr;
5110 Reader.getContext().mergeDefinitionIntoModule(ND: Exported, M: Owner);
5111 Reader.PendingMergedDefinitionsToDeduplicate.insert(X: Exported);
5112 break;
5113 }
5114
5115 case DeclUpdateKind::DeclMarkedOpenMPDeclareTarget: {
5116 auto MapType = Record.readEnum<OMPDeclareTargetDeclAttr::MapTypeTy>();
5117 auto DevType = Record.readEnum<OMPDeclareTargetDeclAttr::DevTypeTy>();
5118 Expr *IndirectE = Record.readExpr();
5119 bool Indirect = Record.readBool();
5120 unsigned Level = Record.readInt();
5121 D->addAttr(A: OMPDeclareTargetDeclAttr::CreateImplicit(
5122 Ctx&: Reader.getContext(), MapType, DevType, IndirectExpr: IndirectE, Indirect, Level,
5123 Range: readSourceRange()));
5124 break;
5125 }
5126
5127 case DeclUpdateKind::AddedAttrToRecord:
5128 AttrVec Attrs;
5129 Record.readAttributes(Attrs);
5130 assert(Attrs.size() == 1);
5131 D->addAttr(A: Attrs[0]);
5132 break;
5133 }
5134 }
5135}
5136