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