clang: lib/Serialization/ASTReaderDecl.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
58#include "llvm/ADT/DenseMap.h"
59#include "llvm/ADT/FoldingSet.h"
60#include "llvm/ADT/STLExtras.h"
61#include "llvm/ADT/SmallPtrSet.h"
62#include "llvm/ADT/SmallVector.h"
63#include "llvm/ADT/iterator_range.h"
64#include "llvm/Bitstream/BitstreamReader.h"
65#include "llvm/Support/Casting.h"
66#include "llvm/Support/ErrorHandling.h"
67#include "llvm/Support/SaveAndRestore.h"
68#include
69#include
70#include
71#include
72#include
73#include
74
75using namespace clang;
76using namespace serialization;
77
78
79
80
81
82namespace {
83
84class RedeclarableResult {
85 Decl *MergeWith;
87 bool IsKeyDecl;
88
89public:
90 RedeclarableResult(Decl *MergeWith, GlobalDeclID FirstID, bool IsKeyDecl)
91 : MergeWith(MergeWith), FirstID(FirstID), IsKeyDecl(IsKeyDecl) {}
92
93
94 GlobalDeclID getFirstID() const { return FirstID; }
95
96
97 bool isKeyDecl() const { return IsKeyDecl; }
98
99
100
101 Decl *getKnownMergeTarget() const { return MergeWith; }
102};
103}
104
108
109public:
111
113 unsigned Number);
114
115
116
117
118
119 template
122
123 template
125 RedeclarableResult &Redecl) {
127 D, Existing, Redecl.isKeyDecl() ? Redecl.getFirstID() : GlobalDeclID());
128 }
129
132
134 struct CXXRecordDecl::DefinitionData &&NewDD);
136 struct ObjCInterfaceDecl::DefinitionData &&NewDD);
138 struct ObjCProtocolDecl::DefinitionData &&NewDD);
139};
140}
141
142
143
144
145
151 ASTReader::RecordLocation Loc;
154
156
157 TypeID DeferredTypeID = 0;
158 unsigned AnonymousDeclNumber = 0;
161
162
163
164
165 bool IsDeclMarkedUsed = false;
166
167 uint64_t GetCurrentCursorOffset();
168
169 uint64_t ReadLocalOffset() {
170 uint64_t LocalOffset = Record.readInt();
171 assert(LocalOffset < Loc.Offset && "offset point after current record");
172 return LocalOffset ? Loc.Offset - LocalOffset : 0;
173 }
174
175 uint64_t ReadGlobalOffset() {
176 uint64_t Local = ReadLocalOffset();
177 return Local ? Record.getGlobalBitOffset(Local) : 0;
178 }
179
181
182 SourceRange readSourceRange() { return Record.readSourceRange(); }
183
185
187
188 std::string readString() { return Record.readString(); }
189
190 Decl *readDecl() { return Record.readDecl(); }
191
192 template T *readDeclAs() { return Record.readDeclAs<T>(); }
193
196 return 0;
197
198 return Record.getGlobalSubmoduleID(Record.readInt());
199 }
200
201 Module *readModule() { return Record.getSubmodule(readSubmoduleID()); }
202
204 Decl *LambdaContext = nullptr,
205 unsigned IndexInLambdaContext = 0);
206 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
208 unsigned IndexInLambdaContext);
209 void ReadObjCDefinitionData(struct ObjCInterfaceDecl::DefinitionData &Data);
210 void ReadObjCDefinitionData(struct ObjCProtocolDecl::DefinitionData &Data);
211
213
218
219
220
221
222
225
226
227
228
229
230
231 class FindExistingResult {
235 bool AddResult = false;
236 unsigned AnonymousDeclNumber = 0;
238
239 public:
240 FindExistingResult(ASTReader &Reader) : Reader(Reader) {}
241
243 unsigned AnonymousDeclNumber,
245 : Reader(Reader), New(New), Existing(Existing), AddResult(true),
246 AnonymousDeclNumber(AnonymousDeclNumber),
247 TypedefNameForLinkage(TypedefNameForLinkage) {}
248
249 FindExistingResult(FindExistingResult &&Other)
250 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
251 AddResult(Other.AddResult),
252 AnonymousDeclNumber(Other.AnonymousDeclNumber),
253 TypedefNameForLinkage(Other.TypedefNameForLinkage) {
254 Other.AddResult = false;
255 }
256
257 FindExistingResult &operator=(FindExistingResult &&) = delete;
258 ~FindExistingResult();
259
260
261
262 void suppress() { AddResult = false; }
263
264 operator NamedDecl *() const { return Existing; }
265
266 template operator T *() const {
267 return dyn_cast_or_null(Existing);
268 }
269 };
270
273 FindExistingResult findExisting(NamedDecl *D);
274
275public:
277 ASTReader::RecordLocation Loc, GlobalDeclID thisDeclID,
280 ThisDeclID(thisDeclID), ThisDeclLoc(ThisDeclLoc) {}
281
282 template
286
287 template
292 Decl *Canon);
293
296
297 template
301
302 template
305
307 llvm::BitstreamCursor &DeclsCursor, bool IsPartial);
308
311
313
316 Cat->NextClassCategory = Next;
317 }
318
341 RedeclarableResult
343
344 void
347 }
348
351 RedeclarableResult
353
356 }
357
387 void
416
418 uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset,
419 uint64_t &TULocalOffset);
420
421 template
423
424 template
426
428 RedeclarableResult &Redecl);
429
431
433
435
436
457};
458}
459
460namespace {
461
462
463
464template class MergedRedeclIterator {
465 DeclT *Start = nullptr;
466 DeclT *Canonical = nullptr;
467 DeclT *Current = nullptr;
468
469public:
470 MergedRedeclIterator() = default;
471 MergedRedeclIterator(DeclT *Start) : Start(Start), Current(Start) {}
472
473 DeclT *operator*() { return Current; }
474
475 MergedRedeclIterator &operator++() {
476 if (Current->isFirstDecl()) {
477 Canonical = Current;
478 Current = Current->getMostRecentDecl();
479 } else
480 Current = Current->getPreviousDecl();
481
482
483
484
485
486 if (Current == Start || Current == Canonical)
487 Current = nullptr;
488 return *this;
489 }
490
491 friend bool operator!=(const MergedRedeclIterator &A,
492 const MergedRedeclIterator &B) {
493 return A.Current != B.Current;
494 }
495};
496
497}
498
499template
500static llvm::iterator_range<MergedRedeclIterator>
502 return llvm::make_range(MergedRedeclIterator(D),
503 MergedRedeclIterator());
504}
505
506uint64_t ASTDeclReader::GetCurrentCursorOffset() {
507 return Loc.F->DeclsCursor.GetCurrentBitNo() + Loc.F->GlobalBitOffset;
508}
509
511 if (Record.readInt()) {
512 Reader.DefinitionSource[FD] =
513 Loc.F->Kind == ModuleKind::MK_MainFile ||
515 }
516 if (auto *CD = dyn_cast(FD)) {
517 CD->setNumCtorInitializers(Record.readInt());
518 if (CD->getNumCtorInitializers())
519 CD->CtorInitializers = ReadGlobalOffset();
520 }
521
522 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
523}
524
527
528
529
531 IsDeclMarkedUsed = false;
532
533 if (auto *DD = dyn_cast(D)) {
534 if (auto *TInfo = DD->getTypeSourceInfo())
535 Record.readTypeLoc(TInfo->getTypeLoc());
536 }
537
538 if (auto *TD = dyn_cast(D)) {
539
541
542
543
544 if (NamedDeclForTagDecl.isValid())
545 cast(D)->TypedefNameDeclOrQualifier =
546 cast(Reader.GetDecl(NamedDeclForTagDecl));
547 } else if (auto *ID = dyn_cast(D)) {
548
550 } else if (auto *FD = dyn_cast(D)) {
551
552 if (Record.readInt())
554 } else if (auto *VD = dyn_cast(D)) {
556 } else if (auto *FD = dyn_cast(D)) {
557 if (FD->hasInClassInitializer() && Record.readInt()) {
558 FD->setLazyInClassInitializer(LazyDeclStmtPtr(GetCurrentCursorOffset()));
559 }
560 }
561}
562
565 auto ModuleOwnership =
569 IsDeclMarkedUsed |= D->Used;
572 bool HasStandaloneLexicalDC = DeclBits.getNextBit();
573 bool HasAttrs = DeclBits.getNextBit();
577
579 isa<ParmVarDecl, ObjCTypeParamDecl>(D)) {
580
581
582
583
584
585
586 GlobalDeclID SemaDCIDForTemplateParmDecl = readDeclID();
587 GlobalDeclID LexicalDCIDForTemplateParmDecl =
588 HasStandaloneLexicalDC ? readDeclID() : GlobalDeclID();
589 if (LexicalDCIDForTemplateParmDecl.isInvalid())
590 LexicalDCIDForTemplateParmDecl = SemaDCIDForTemplateParmDecl;
591 Reader.addPendingDeclContextInfo(D,
592 SemaDCIDForTemplateParmDecl,
593 LexicalDCIDForTemplateParmDecl);
595 } else {
596 auto *SemaDC = readDeclAs();
597 auto *LexicalDC =
598 HasStandaloneLexicalDC ? readDeclAs() : nullptr;
599 if (!LexicalDC)
600 LexicalDC = SemaDC;
601
602
604 if (auto *RD = dyn_cast(SemaDC))
605 MergedSemaDC = getOrFakePrimaryClassDefinition(Reader, RD);
606 else
607 MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
608
609
610 D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
612 }
614
615 if (HasAttrs) {
617 Record.readAttributes(Attrs);
618
619
620 D->setAttrsImpl(Attrs, Reader.getContext());
621 }
622
623
624
625 bool ModulePrivate =
627 if (unsigned SubmoduleID = readSubmoduleID()) {
628 switch (ModuleOwnership) {
631 break;
636 break;
637 }
638
640
642
643 if (ModulePrivate) {
644
645
647
648
650
653 else
654 Reader.HiddenNamesMap[Owner].push_back(D);
655 }
656 } else if (ModulePrivate) {
658 }
659}
660
665 std::string Arg = readString();
666 memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());
667 D->getTrailingObjects<char>()[Arg.size()] = '\0';
668}
669
673 std::string Name = readString();
674 memcpy(D->getTrailingObjects<char>(), Name.data(), Name.size());
675 D->getTrailingObjects<char>()[Name.size()] = '\0';
676
677 D->ValueStart = Name.size() + 1;
678 std::string Value = readString();
679 memcpy(D->getTrailingObjects<char>() + D->ValueStart, Value.data(),
681 D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';
682}
683
685 llvm_unreachable("Translation units are not serialized");
686}
687
691 AnonymousDeclNumber = Record.readInt();
692}
693
697
698 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());
699}
700
705 if (Record.readInt()) {
708 } else
710
711
712
713
714 readDecl();
715 return Redecl;
716}
717
721}
722
725 if (auto *Template = readDeclAs())
726
728 else
730}
731
735
737
746
747 switch (TagDeclBits.getNextBits(2)) {
748 case 0:
749 break;
750 case 1: {
752 Record.readQualifierInfo(*Info);
753 TD->TypedefNameDeclOrQualifier = Info;
754 break;
755 }
756 case 2:
757 NamedDeclForTagDecl = readDeclID();
758 TypedefNameForLinkage = Record.readIdentifier();
759 break;
760 default:
761 llvm_unreachable("unexpected tag info kind");
762 }
763
764 if (!isa(TD))
766 return Redecl;
767}
768
773 else
776
778 ED->setNumPositiveBits(EnumDeclBits.getNextBits(8));
779 ED->setNumNegativeBits(EnumDeclBits.getNextBits(8));
783
784 ED->setHasODRHash(true);
785 ED->ODRHash = Record.readInt();
786
787
788
791 if (!OldDef) {
792
793
796 OldDef = D;
797 break;
798 }
799 }
800 }
801 if (OldDef) {
802 Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
805
806
809 Reader.PendingEnumOdrMergeFailures[OldDef].push_back(ED);
810 } else {
811 OldDef = ED;
812 }
813 }
814
815 if (auto *InstED = readDeclAs()) {
818 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
820 }
821}
822
824 RedeclarableResult Redecl = VisitTagDecl(RD);
825
842 return Redecl;
843}
844
847 RD->setODRHash(Record.readInt());
848
849
850
853 RecordDecl *&OldDef = Reader.RecordDefinitions[Canon];
854 if (!OldDef) {
855
856
859 OldDef = D;
860 break;
861 }
862 }
863 }
864 if (OldDef) {
865 Reader.MergedDeclContexts.insert(std::make_pair(RD, OldDef));
869 Reader.PendingRecordOdrMergeFailures[OldDef].push_back(RD);
870 } else {
871 OldDef = RD;
872 }
873 }
874}
875
878
879
880
881 if (isa<FunctionDecl, VarDecl>(VD))
882 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());
883 else
885}
886
889 if (Record.readInt())
893}
894
898 if (Record.readInt()) {
899 auto *Info = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
900 Record.readQualifierInfo(*Info);
901 Info->TrailingRequiresClause = Record.readExpr();
902 DD->DeclInfo = Info;
903 }
906 TSIType.isNull() ? nullptr
908}
909
912
914
917 break;
920 break;
922 auto *Template = readDeclAs();
923 Template->init(FD);
925 break;
926 }
928 auto *InstFD = readDeclAs();
931 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
933 break;
934 }
936 auto *Template = readDeclAs();
938
939
941 Record.readTemplateArgumentList(TemplArgs, true);
942
943
945 bool HasTemplateArgumentsAsWritten = Record.readBool();
946 if (HasTemplateArgumentsAsWritten)
947 Record.readTemplateArgumentListInfo(TemplArgsWritten);
948
950
954
956 if (Record.readInt()) {
957 auto *FD = readDeclAs();
960
963 }
964
967 C, FD, Template, TSK, TemplArgList,
968 HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr, POI,
969 MSInfo);
970 FD->TemplateOrSpecialization = FTInfo;
971
972 if (FD->isCanonicalDecl()) {
973
974
975 auto *CanonTemplate = readDeclAs();
976
977
978
979
980
981 llvm::FoldingSetNodeID ID;
983 void *InsertPos = nullptr;
986 CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
987 if (InsertPos)
988 CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
989 else {
991 "already deserialized this template specialization");
993 }
994 }
995 break;
996 }
998
1000 unsigned NumCandidates = Record.readInt();
1001 while (NumCandidates--)
1002 Candidates.addDecl(readDeclAs());
1003
1004
1006 bool HasTemplateArgumentsAsWritten = Record.readBool();
1007 if (HasTemplateArgumentsAsWritten)
1008 Record.readTemplateArgumentListInfo(TemplArgsWritten);
1009
1012 HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr);
1013
1014
1015 break;
1016 }
1017 }
1018
1020
1021
1022
1028
1029
1031 Reader.PendingDeducedFunctionTypes.push_back({FD, DeferredTypeID});
1032 } else {
1034 }
1035 DeferredTypeID = 0;
1036
1039
1040
1041
1043
1050
1051
1052
1053 const bool Pure = FunctionDeclBits.getNextBit();
1070
1071 FD->EndRangeLoc = readSourceLocation();
1074
1075 FD->ODRHash = Record.readInt();
1076 FD->setHasODRHash(true);
1077
1079
1080
1081
1082 if (auto Info = Record.readInt()) {
1083 bool HasMessage = Info & 2;
1085 HasMessage ? cast(Record.readExpr()) : nullptr;
1086
1087 unsigned NumLookups = Record.readInt();
1089 for (unsigned I = 0; I != NumLookups; ++I) {
1093 }
1094
1097 Reader.getContext(), Lookups, DeletedMessage));
1098 }
1099 }
1100
1101 if (Existing)
1106
1107
1108 auto merge = [this, &Redecl, FD](auto &&F) {
1109 auto *Existing = cast_or_null(Redecl.getKnownMergeTarget());
1110 RedeclarableResult NewRedecl(Existing ? F(Existing) : nullptr,
1111 Redecl.getFirstID(), Redecl.isKeyDecl());
1113 };
1115 merge(
1117 else
1120 });
1121 } else
1123
1124
1125
1127
1128
1129 unsigned NumParams = Record.readInt();
1131 Params.reserve(NumParams);
1132 for (unsigned I = 0; I != NumParams; ++I)
1133 Params.push_back(readDeclAs());
1134 FD->setParams(Reader.getContext(), Params);
1135
1136
1137
1138
1139 if (FD->hasAttr()) {
1140 auto *SKEPAttr = FD->getAttr();
1142 const SYCLKernelInfo *SKI = C.findSYCLKernelInfo(SKEPAttr->getKernelName());
1143 if (SKI) {
1145 Reader.Diag(FD->getLocation(), diag::err_sycl_kernel_name_conflict);
1147 diag::note_previous_declaration);
1148 SKEPAttr->setInvalidAttr();
1149 }
1150 } else {
1151 C.registerSYCLEntryPointFunction(FD);
1152 }
1153 }
1154}
1155
1158 if (Record.readInt()) {
1159
1160
1161 Reader.PendingBodies[MD] = GetCurrentCursorOffset();
1162 }
1163 MD->setSelfDecl(readDeclAs());
1164 MD->setCmdDecl(readDeclAs());
1172
1177 readDeclAs());
1178
1185 MD->DeclEndLoc = readSourceLocation();
1186 unsigned NumParams = Record.readInt();
1188 Params.reserve(NumParams);
1189 for (unsigned I = 0; I != NumParams; ++I)
1190 Params.push_back(readDeclAs());
1191
1193 unsigned NumStoredSelLocs = Record.readInt();
1195 SelLocs.reserve(NumStoredSelLocs);
1196 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
1197 SelLocs.push_back(readSourceLocation());
1198
1199 MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
1200}
1201
1204
1205 D->Variance = Record.readInt();
1206 D->Index = Record.readInt();
1207 D->VarianceLoc = readSourceLocation();
1208 D->ColonLoc = readSourceLocation();
1209}
1210
1215}
1216
1218 unsigned numParams = Record.readInt();
1219 if (numParams == 0)
1220 return nullptr;
1221
1223 typeParams.reserve(numParams);
1224 for (unsigned i = 0; i != numParams; ++i) {
1225 auto *typeParam = readDeclAs();
1226 if (!typeParam)
1227 return nullptr;
1228
1229 typeParams.push_back(typeParam);
1230 }
1231
1234
1236 typeParams, rAngleLoc);
1237}
1238
1239void ASTDeclReader::ReadObjCDefinitionData(
1240 struct ObjCInterfaceDecl::DefinitionData &Data) {
1241
1242 Data.SuperClassTInfo = readTypeSourceInfo();
1243
1244 Data.EndLoc = readSourceLocation();
1245 Data.HasDesignatedInitializers = Record.readInt();
1247 Data.HasODRHash = true;
1248
1249
1250 unsigned NumProtocols = Record.readInt();
1252 Protocols.reserve(NumProtocols);
1253 for (unsigned I = 0; I != NumProtocols; ++I)
1254 Protocols.push_back(readDeclAs());
1256 ProtoLocs.reserve(NumProtocols);
1257 for (unsigned I = 0; I != NumProtocols; ++I)
1258 ProtoLocs.push_back(readSourceLocation());
1259 Data.ReferencedProtocols.set(Protocols.data(), NumProtocols, ProtoLocs.data(),
1261
1262
1263 NumProtocols = Record.readInt();
1264 Protocols.clear();
1265 Protocols.reserve(NumProtocols);
1266 for (unsigned I = 0; I != NumProtocols; ++I)
1267 Protocols.push_back(readDeclAs());
1268 Data.AllReferencedProtocols.set(Protocols.data(), NumProtocols,
1270}
1271
1273 ObjCInterfaceDecl *D, struct ObjCInterfaceDecl::DefinitionData &&NewDD) {
1274 struct ObjCInterfaceDecl::DefinitionData &DD = D->data();
1275 if (DD.Definition == NewDD.Definition)
1276 return;
1277
1278 Reader.MergedDeclContexts.insert(
1279 std::make_pair(NewDD.Definition, DD.Definition));
1281
1282 if (D->getODRHash() != NewDD.ODRHash)
1283 Reader.PendingObjCInterfaceOdrMergeFailures[DD.Definition].push_back(
1284 {NewDD.Definition, &NewDD});
1285}
1286
1290 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());
1292
1294 if (Record.readInt()) {
1295
1296 ID->allocateDefinitionData();
1297
1298 ReadObjCDefinitionData(ID->data());
1300 if (Canon->Data.getPointer()) {
1301
1302
1304 ID->Data = Canon->Data;
1305 } else {
1306
1307
1308 ID->getCanonicalDecl()->Data = ID->Data;
1309
1310
1311 ID->setIvarList(nullptr);
1312 }
1313
1314
1315 Reader.PendingDefinitions.insert(ID);
1316
1317
1318 Reader.ObjCClassesLoaded.push_back(ID);
1319 } else {
1320 ID->Data = ID->getCanonicalDecl()->Data;
1321 }
1322}
1323
1327
1329 bool synth = Record.readInt();
1331
1332
1334 return;
1335
1336
1337
1339 return;
1344 if (PrevIvar && PrevIvar != IVD) {
1345 auto *ParentExt = dyn_cast(IVD->getDeclContext());
1346 auto *PrevParentExt =
1347 dyn_cast(PrevIvar->getDeclContext());
1348 if (ParentExt && PrevParentExt) {
1349
1350
1351 Reader
1352 .PendingObjCExtensionIvarRedeclarations[std::make_pair(ParentExt,
1353 PrevParentExt)]
1354 .push_back(std::make_pair(IVD, PrevIvar));
1355 } else if (ParentExt || PrevParentExt) {
1356
1357
1358
1359 Reader.Diag(IVD->getLocation(), diag::err_duplicate_ivar_declaration)
1360 << II;
1361 Reader.Diag(PrevIvar->getLocation(), diag::note_previous_definition);
1362 }
1363 }
1364}
1365
1366void ASTDeclReader::ReadObjCDefinitionData(
1367 struct ObjCProtocolDecl::DefinitionData &Data) {
1368 unsigned NumProtoRefs = Record.readInt();
1370 ProtoRefs.reserve(NumProtoRefs);
1371 for (unsigned I = 0; I != NumProtoRefs; ++I)
1372 ProtoRefs.push_back(readDeclAs());
1374 ProtoLocs.reserve(NumProtoRefs);
1375 for (unsigned I = 0; I != NumProtoRefs; ++I)
1376 ProtoLocs.push_back(readSourceLocation());
1377 Data.ReferencedProtocols.set(ProtoRefs.data(), NumProtoRefs,
1378 ProtoLocs.data(), Reader.getContext());
1380 Data.HasODRHash = true;
1381}
1382
1384 ObjCProtocolDecl *D, struct ObjCProtocolDecl::DefinitionData &&NewDD) {
1385 struct ObjCProtocolDecl::DefinitionData &DD = D->data();
1386 if (DD.Definition == NewDD.Definition)
1387 return;
1388
1389 Reader.MergedDeclContexts.insert(
1390 std::make_pair(NewDD.Definition, DD.Definition));
1392
1393 if (D->getODRHash() != NewDD.ODRHash)
1394 Reader.PendingObjCProtocolOdrMergeFailures[DD.Definition].push_back(
1395 {NewDD.Definition, &NewDD});
1396}
1397
1402
1403 if (Record.readInt()) {
1404
1405 PD->allocateDefinitionData();
1406
1407 ReadObjCDefinitionData(PD->data());
1408
1410 if (Canon->Data.getPointer()) {
1411
1412
1414 PD->Data = Canon->Data;
1415 } else {
1416
1417
1419 }
1420
1421 Reader.PendingDefinitions.insert(PD);
1422 } else {
1424 }
1425}
1426
1429}
1430
1436
1437
1438
1439
1440 Reader.CategoriesDeserialized.insert(CD);
1441
1442 CD->ClassInterface = readDeclAs();
1444 unsigned NumProtoRefs = Record.readInt();
1446 ProtoRefs.reserve(NumProtoRefs);
1447 for (unsigned I = 0; I != NumProtoRefs; ++I)
1448 ProtoRefs.push_back(readDeclAs());
1450 ProtoLocs.reserve(NumProtoRefs);
1451 for (unsigned I = 0; I != NumProtoRefs; ++I)
1452 ProtoLocs.push_back(readSourceLocation());
1453 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
1455
1456
1457 if (NumProtoRefs > 0 && CD->ClassInterface && CD->IsClassExtension())
1461}
1462
1466}
1467
1470 D->setAtLoc(readSourceLocation());
1471 D->setLParenLoc(readSourceLocation());
1476 D->setPropertyAttributesAsWritten(
1478 D->setPropertyImplementation(
1486 D->setGetterMethodDecl(readDeclAs());
1487 D->setSetterMethodDecl(readDeclAs());
1488 D->setPropertyIvarDecl(readDeclAs());
1489}
1490
1493 D->setClassInterface(readDeclAs());
1494}
1495
1498 D->CategoryNameLoc = readSourceLocation();
1499}
1500
1503 D->setSuperClass(readDeclAs());
1504 D->SuperLoc = readSourceLocation();
1505 D->setIvarLBraceLoc(readSourceLocation());
1506 D->setIvarRBraceLoc(readSourceLocation());
1507 D->setHasNonZeroConstructors(Record.readInt());
1508 D->setHasDestructors(Record.readInt());
1509 D->NumIvarInitializers = Record.readInt();
1510 if (D->NumIvarInitializers)
1511 D->IvarInitializers = ReadGlobalOffset();
1512}
1513
1516 D->setAtLoc(readSourceLocation());
1517 D->setPropertyDecl(readDeclAs());
1518 D->PropertyIvarDecl = readDeclAs();
1519 D->IvarLoc = readSourceLocation();
1520 D->setGetterMethodDecl(readDeclAs());
1521 D->setSetterMethodDecl(readDeclAs());
1522 D->setGetterCXXConstructor(Record.readExpr());
1523 D->setSetterCXXAssignment(Record.readExpr());
1524}
1525
1528 FD->Mutable = Record.readInt();
1529
1530 unsigned Bits = Record.readInt();
1531 FD->StorageKind = Bits >> 1;
1532 if (FD->StorageKind == FieldDecl::ISK_CapturedVLAType)
1534 cast(Record.readType().getTypePtr());
1535 else if (Bits & 1)
1537
1540 if (auto *Tmpl = readDeclAs())
1542 }
1544}
1545
1548 PD->GetterId = Record.readIdentifier();
1549 PD->SetterId = Record.readIdentifier();
1550}
1551
1554 D->PartVal.Part1 = Record.readInt();
1555 D->PartVal.Part2 = Record.readInt();
1556 D->PartVal.Part3 = Record.readInt();
1557 for (auto &C : D->PartVal.Part4And5)
1559
1560
1563}
1564
1568 D->Value = Record.readAPValue();
1569
1570
1572 Reader.getContext().UnnamedGlobalConstantDecls.GetOrInsertNode(D))
1574}
1575
1578 D->Value = Record.readAPValue();
1579
1580
1581
1583 Reader.getContext().TemplateParamObjectDecls.GetOrInsertNode(D))
1585}
1586
1589
1590 FD->ChainingSize = Record.readInt();
1591 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1593
1594 for (unsigned I = 0; I != FD->ChainingSize; ++I)
1595 FD->Chaining[I] = readDeclAs();
1596
1598}
1599
1603
1606 bool DefGeneratedInModule = VarDeclBits.getNextBit();
1611 bool HasDeducedType = false;
1612 if (!isa(VD)) {
1618
1625
1627 HasDeducedType = VarDeclBits.getNextBit();
1630
1632 }
1633
1634
1635
1636
1637 if (HasDeducedType)
1638 Reader.PendingDeducedVarTypes.push_back({VD, DeferredTypeID});
1639 else
1641 DeferredTypeID = 0;
1642
1644
1645
1649
1650 if (DefGeneratedInModule) {
1651 Reader.DefinitionSource[VD] =
1652 Loc.F->Kind == ModuleKind::MK_MainFile ||
1654 }
1655
1656 if (VD->hasAttr()) {
1658 if (CopyExpr)
1660 }
1661
1662 enum VarKind {
1663 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1664 };
1665 switch ((VarKind)Record.readInt()) {
1666 case VarNotTemplate:
1667
1668
1669 if (!isa(VD) && !isa(VD) &&
1670 !isa(VD))
1672 break;
1673 case VarTemplate:
1674
1676 break;
1677 case StaticDataMemberSpecialization: {
1678 auto *Tmpl = readDeclAs();
1683 break;
1684 }
1685 }
1686
1687 return Redecl;
1688}
1689
1691 if (uint64_t Val = Record.readInt()) {
1700 }
1701
1702
1703
1704
1705 Eval->Value = GetCurrentCursorOffset();
1706 }
1707}
1708
1711}
1712
1715
1716 unsigned scopeIndex = Record.readInt();
1718 unsigned isObjCMethodParam = ParmVarDeclBits.getNextBit();
1719 unsigned scopeDepth = ParmVarDeclBits.getNextBits(7);
1720 unsigned declQualifier = ParmVarDeclBits.getNextBits(7);
1721 if (isObjCMethodParam) {
1722 assert(scopeDepth == 0);
1724 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1725 } else {
1727 }
1729
1731 if (ParmVarDeclBits.getNextBit())
1733
1734 if (ParmVarDeclBits.getNextBit())
1735 PD->ExplicitObjectParameterIntroducerLoc = Record.readSourceLocation();
1736
1737
1738
1739}
1740
1743 auto **BDs = DD->getTrailingObjects<BindingDecl *>();
1744 for (unsigned I = 0; I != DD->NumBindings; ++I) {
1745 BDs[I] = readDeclAs();
1746 BDs[I]->setDecomposedDecl(DD);
1747 }
1748}
1749
1752 BD->Binding = Record.readExpr();
1753}
1754
1759}
1760
1763 D->Statement = Record.readStmt();
1764}
1765
1768 BD->setBody(cast_or_null(Record.readStmt()));
1770 unsigned NumParams = Record.readInt();
1772 Params.reserve(NumParams);
1773 for (unsigned I = 0; I != NumParams; ++I)
1774 Params.push_back(readDeclAs());
1776
1782
1783 bool capturesCXXThis = Record.readInt();
1784 unsigned numCaptures = Record.readInt();
1786 captures.reserve(numCaptures);
1787 for (unsigned i = 0; i != numCaptures; ++i) {
1788 auto *decl = readDeclAs();
1789 unsigned flags = Record.readInt();
1790 bool byRef = (flags & 1);
1791 bool nested = (flags & 2);
1792 Expr *copyExpr = ((flags & 4) ? Record.readExpr() : nullptr);
1793
1795 }
1797}
1798
1800
1802 for (unsigned I = 0; I < D->NumParams; ++I)
1803 D->setParam(I, readDeclAs());
1804 D->setNothrow(Record.readInt() != 0);
1805 D->setBody(cast_or_null(Record.readStmt()));
1806}
1807
1810 unsigned ContextParamPos = Record.readInt();
1812
1813 for (unsigned I = 0; I < CD->NumParams; ++I) {
1814 if (I != ContextParamPos)
1815 CD->setParam(I, readDeclAs());
1816 else
1817 CD->setContextParam(I, readDeclAs());
1818 }
1819}
1820
1824 D->setExternLoc(readSourceLocation());
1825 D->setRBraceLoc(readSourceLocation());
1826}
1827
1830 D->RBraceLoc = readSourceLocation();
1831}
1832
1835 D->setLocStart(readSourceLocation());
1836}
1837
1841
1843 D->setInline(NamespaceDeclBits.getNextBit());
1844 D->setNested(NamespaceDeclBits.getNextBit());
1845 D->LocStart = readSourceLocation();
1846 D->RBraceLoc = readSourceLocation();
1847
1848
1849
1850
1851
1853 if (Redecl.getFirstID() == ThisDeclID)
1854 AnonNamespace = readDeclID();
1855
1857
1858 if (AnonNamespace.isValid()) {
1859
1860
1861
1862 auto *Anon = cast(Reader.GetDecl(AnonNamespace));
1863 if (.isModule())
1864 D->setAnonymousNamespace(Anon);
1865 }
1866}
1867
1870 uint64_t LexicalOffset = 0;
1871 uint64_t VisibleOffset = 0;
1872 uint64_t ModuleLocalOffset = 0;
1873 uint64_t TULocalOffset = 0;
1874 VisitDeclContext(D, LexicalOffset, VisibleOffset, ModuleLocalOffset,
1875 TULocalOffset);
1876 D->IsCBuffer = Record.readBool();
1877 D->KwLoc = readSourceLocation();
1878 D->LBraceLoc = readSourceLocation();
1879 D->RBraceLoc = readSourceLocation();
1880}
1881
1885 D->NamespaceLoc = readSourceLocation();
1886 D->IdentLoc = readSourceLocation();
1887 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1888 D->Namespace = readDeclAs();
1890}
1891
1894 D->setUsingLoc(readSourceLocation());
1895 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1896 D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());
1897 D->FirstUsingShadow.setPointer(readDeclAs());
1898 D->setTypename(Record.readInt());
1899 if (auto *Pattern = readDeclAs())
1902}
1903
1906 D->setUsingLoc(readSourceLocation());
1907 D->setEnumLoc(readSourceLocation());
1908 D->setEnumType(Record.readTypeSourceInfo());
1909 D->FirstUsingShadow.setPointer(readDeclAs());
1910 if (auto *Pattern = readDeclAs())
1913}
1914
1917 D->InstantiatedFrom = readDeclAs();
1918 auto **Expansions = D->getTrailingObjects<NamedDecl *>();
1919 for (unsigned I = 0; I != D->NumExpansions; ++I)
1920 Expansions[I] = readDeclAs();
1922}
1923
1927 D->Underlying = readDeclAs();
1929 D->UsingOrNextShadow = readDeclAs();
1930 auto *Pattern = readDeclAs();
1931 if (Pattern)
1934}
1935
1939 D->NominatedBaseClassShadowDecl = readDeclAs();
1940 D->ConstructedBaseClassShadowDecl = readDeclAs();
1941 D->IsVirtual = Record.readInt();
1942}
1943
1946 D->UsingLoc = readSourceLocation();
1947 D->NamespaceLoc = readSourceLocation();
1948 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1949 D->NominatedNamespace = readDeclAs();
1950 D->CommonAncestor = readDeclAs();
1951}
1952
1955 D->setUsingLoc(readSourceLocation());
1956 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1957 D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());
1958 D->EllipsisLoc = readSourceLocation();
1960}
1961
1965 D->TypenameLocation = readSourceLocation();
1966 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1967 D->EllipsisLoc = readSourceLocation();
1969}
1970
1974}
1975
1976void ASTDeclReader::ReadCXXDefinitionData(
1978 Decl *LambdaContext, unsigned IndexInLambdaContext) {
1979
1981
1982#define FIELD(Name, Width, Merge) \
1983 if (!CXXRecordDeclBits.canGetNextNBits(Width)) \
1984 CXXRecordDeclBits.updateValue(Record.readInt()); \
1985 Data.Name = CXXRecordDeclBits.getNextBits(Width);
1986
1987#include "clang/AST/CXXRecordDeclDefinitionBits.def"
1988#undef FIELD
1989
1990
1992 Data.HasODRHash = true;
1993
1994 if (Record.readInt()) {
1995 Reader.DefinitionSource[D] =
1996 Loc.F->Kind == ModuleKind::MK_MainFile ||
1998 }
1999
2000 Record.readUnresolvedSet(Data.Conversions);
2001 Data.ComputedVisibleConversions = Record.readInt();
2002 if (Data.ComputedVisibleConversions)
2003 Record.readUnresolvedSet(Data.VisibleConversions);
2004 assert(Data.Definition && "Data.Definition should be already set!");
2005
2006 if (.IsLambda) {
2007 assert(!LambdaContext && !IndexInLambdaContext &&
2008 "given lambda context for non-lambda");
2009
2011 if (Data.NumBases)
2012 Data.Bases = ReadGlobalOffset();
2013
2015 if (Data.NumVBases)
2016 Data.VBases = ReadGlobalOffset();
2017
2019 } else {
2021
2022 auto &Lambda = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
2023
2025 Lambda.DependencyKind = LambdaBits.getNextBits(2);
2026 Lambda.IsGenericLambda = LambdaBits.getNextBit();
2027 Lambda.CaptureDefault = LambdaBits.getNextBits(2);
2028 Lambda.NumCaptures = LambdaBits.getNextBits(15);
2029 Lambda.HasKnownInternalLinkage = LambdaBits.getNextBit();
2030
2031 Lambda.NumExplicitCaptures = Record.readInt();
2032 Lambda.ManglingNumber = Record.readInt();
2033 if (unsigned DeviceManglingNumber = Record.readInt())
2034 Reader.getContext().DeviceLambdaManglingNumbers[D] = DeviceManglingNumber;
2035 Lambda.IndexInContext = IndexInLambdaContext;
2036 Lambda.ContextDecl = LambdaContext;
2037 Capture *ToCapture = nullptr;
2038 if (Lambda.NumCaptures) {
2040 Lambda.NumCaptures);
2041 Lambda.AddCaptureList(Reader.getContext(), ToCapture);
2042 }
2043 Lambda.MethodTyInfo = readTypeSourceInfo();
2044 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
2047 bool IsImplicit = CaptureBits.getNextBit();
2049 static_cast<LambdaCaptureKind>(CaptureBits.getNextBits(3));
2050 switch (Kind) {
2054 new (ToCapture)
2056 ToCapture++;
2057 break;
2060 auto *Var = readDeclAs();
2062 new (ToCapture) Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
2063 ToCapture++;
2064 break;
2065 }
2066 }
2067 }
2068}
2069
2071 CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {
2072 assert(D->DefinitionData &&
2073 "merging class definition into non-definition");
2074 auto &DD = *D->DefinitionData;
2075
2076 if (DD.Definition != MergeDD.Definition) {
2077
2078 Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,
2079 DD.Definition));
2080 Reader.PendingDefinitions.erase(MergeDD.Definition);
2081 MergeDD.Definition->demoteThisDefinitionToDeclaration();
2083 assert(!Reader.Lookups.contains(MergeDD.Definition) &&
2084 "already loaded pending lookups for merged definition");
2085 }
2086
2087 auto PFDI = Reader.PendingFakeDefinitionData.find(&DD);
2088 if (PFDI != Reader.PendingFakeDefinitionData.end() &&
2089 PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {
2090
2091
2092 assert(!DD.IsLambda && !MergeDD.IsLambda && "faked up lambda definition?");
2093 PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;
2094
2095
2096
2097 auto *Def = DD.Definition;
2098 DD = std::move(MergeDD);
2099 DD.Definition = Def;
2100 return;
2101 }
2102
2103 bool DetectedOdrViolation = false;
2104
2105 #define FIELD(Name, Width, Merge) Merge(Name)
2106 #define MERGE_OR(Field) DD.Field |= MergeDD.Field;
2107 #define NO_MERGE(Field) \
2108 DetectedOdrViolation |= DD.Field != MergeDD.Field; \
2109 MERGE_OR(Field)
2110 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2112 #undef NO_MERGE
2113 #undef MERGE_OR
2114
2115 if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
2116 DetectedOdrViolation = true;
2117
2118
2119
2120
2121
2122 if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
2123 DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
2124 DD.ComputedVisibleConversions = true;
2125 }
2126
2127
2128
2129
2130 if (DD.IsLambda) {
2131 auto &Lambda1 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(DD);
2132 auto &Lambda2 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(MergeDD);
2133 DetectedOdrViolation |= Lambda1.DependencyKind != Lambda2.DependencyKind;
2134 DetectedOdrViolation |= Lambda1.IsGenericLambda != Lambda2.IsGenericLambda;
2135 DetectedOdrViolation |= Lambda1.CaptureDefault != Lambda2.CaptureDefault;
2136 DetectedOdrViolation |= Lambda1.NumCaptures != Lambda2.NumCaptures;
2137 DetectedOdrViolation |=
2138 Lambda1.NumExplicitCaptures != Lambda2.NumExplicitCaptures;
2139 DetectedOdrViolation |=
2140 Lambda1.HasKnownInternalLinkage != Lambda2.HasKnownInternalLinkage;
2141 DetectedOdrViolation |= Lambda1.ManglingNumber != Lambda2.ManglingNumber;
2142
2143 if (Lambda1.NumCaptures && Lambda1.NumCaptures == Lambda2.NumCaptures) {
2144 for (unsigned I = 0, N = Lambda1.NumCaptures; I != N; ++I) {
2145 LambdaCapture &Cap1 = Lambda1.Captures.front()[I];
2146 LambdaCapture &Cap2 = Lambda2.Captures.front()[I];
2148 }
2149 Lambda1.AddCaptureList(Reader.getContext(), Lambda2.Captures.front());
2150 }
2151 }
2152
2153
2155 return;
2156
2157 if (D->getODRHash() != MergeDD.ODRHash) {
2158 DetectedOdrViolation = true;
2159 }
2160
2161 if (DetectedOdrViolation)
2162 Reader.PendingOdrMergeFailures[DD.Definition].push_back(
2163 {MergeDD.Definition, &MergeDD});
2164}
2165
2167 Decl *LambdaContext,
2168 unsigned IndexInLambdaContext) {
2169 struct CXXRecordDecl::DefinitionData *DD;
2171
2172
2173
2174 bool IsLambda = Record.readInt();
2175 assert(!(IsLambda && Update) &&
2176 "lambda definition should not be added by update record");
2177 if (IsLambda)
2178 DD = new (C) CXXRecordDecl::LambdaDefinitionData(
2180 else
2181 DD = new (C) struct CXXRecordDecl::DefinitionData(D);
2182
2184
2185
2186
2187 if (!Canon->DefinitionData)
2188 Canon->DefinitionData = DD;
2189 D->DefinitionData = Canon->DefinitionData;
2190 ReadCXXDefinitionData(*DD, D, LambdaContext, IndexInLambdaContext);
2191
2192
2193 D->setCompleteDefinition(true);
2194
2195
2196
2197
2198 if (Canon->DefinitionData != DD) {
2200 return;
2201 }
2202
2203
2204
2205
2206 if (Update || Canon != D)
2207 Reader.PendingDefinitions.insert(D);
2208}
2209
2212
2214
2215 enum CXXRecKind {
2216 CXXRecNotTemplate = 0,
2217 CXXRecTemplate,
2218 CXXRecMemberSpecialization,
2219 CXXLambda
2220 };
2221
2222 Decl *LambdaContext = nullptr;
2223 unsigned IndexInLambdaContext = 0;
2224
2225 switch ((CXXRecKind)Record.readInt()) {
2226 case CXXRecNotTemplate:
2227
2228 if (!isa(D))
2230 break;
2231 case CXXRecTemplate: {
2232
2233 auto *Template = readDeclAs();
2234 D->TemplateOrInstantiation = Template;
2235 if (!Template->getTemplatedDecl()) {
2236
2237
2238
2239
2240
2241
2242 DeferredTypeID = 0;
2243 }
2244 break;
2245 }
2246 case CXXRecMemberSpecialization: {
2247 auto *RD = readDeclAs();
2252 D->TemplateOrInstantiation = MSI;
2254 break;
2255 }
2256 case CXXLambda: {
2257 LambdaContext = readDecl();
2258 if (LambdaContext)
2259 IndexInLambdaContext = Record.readInt();
2260 if (LambdaContext)
2261 MergeImpl.mergeLambda(D, Redecl, *LambdaContext, IndexInLambdaContext);
2262 else
2263
2264
2266 break;
2267 }
2268 }
2269
2270 bool WasDefinition = Record.readInt();
2271 if (WasDefinition)
2272 ReadCXXRecordDefinition(D, false, LambdaContext,
2273 IndexInLambdaContext);
2274 else
2275
2277
2278
2279
2280 if (WasDefinition) {
2282 if (KeyFn.isValid() && D->isCompleteDefinition())
2283
2284
2285
2287 }
2288
2289 return Redecl;
2290}
2291
2293 D->setExplicitSpecifier(Record.readExplicitSpec());
2294 D->Ctor = readDeclAs();
2296 D->setDeductionCandidateKind(
2298}
2299
2302
2303 unsigned NumOverridenMethods = Record.readInt();
2305 while (NumOverridenMethods--) {
2306
2307
2308 if (auto *MD = readDeclAs())
2310 }
2311 } else {
2312
2313
2314 Record.skipInts(NumOverridenMethods);
2315 }
2316}
2317
2319
2320
2321 D->setExplicitSpecifier(Record.readExplicitSpec());
2322 if (D->isInheritingConstructor()) {
2323 auto *Shadow = readDeclAs();
2324 auto *Ctor = readDeclAs();
2327 }
2328
2330}
2331
2334
2335 if (auto *OperatorDelete = readDeclAs()) {
2337 auto *ThisArg = Record.readExpr();
2338
2339 if (!Canon->OperatorDelete) {
2340 Canon->OperatorDelete = OperatorDelete;
2341 Canon->OperatorDeleteThisArg = ThisArg;
2342 }
2343 }
2344}
2345
2347 D->setExplicitSpecifier(Record.readExplicitSpec());
2349}
2350
2353 D->ImportedModule = readModule();
2354 D->setImportComplete(Record.readInt());
2355 auto *StoredLocs = D->getTrailingObjects<SourceLocation>();
2356 for (unsigned I = 0, N = Record.back(); I != N; ++I)
2357 StoredLocs[I] = readSourceLocation();
2358 Record.skipInts(1);
2359}
2360
2363 D->setColonLoc(readSourceLocation());
2364}
2365
2368 if (Record.readInt())
2369 D->Friend = readDeclAs();
2370 else
2371 D->Friend = readTypeSourceInfo();
2372 for (unsigned i = 0; i != D->NumTPLists; ++i)
2374 Record.readTemplateParameterList();
2376 D->UnsupportedFriend = (Record.readInt() != 0);
2377 D->FriendLoc = readSourceLocation();
2378 D->EllipsisLoc = readSourceLocation();
2379}
2380
2383 unsigned NumParams = Record.readInt();
2384 D->NumParams = NumParams;
2386 for (unsigned i = 0; i != NumParams; ++i)
2387 D->Params[i] = Record.readTemplateParameterList();
2388 if (Record.readInt())
2389 D->Friend = readDeclAs();
2390 else
2391 D->Friend = readTypeSourceInfo();
2392 D->FriendLoc = readSourceLocation();
2393}
2394
2397
2398 assert(->TemplateParams && "TemplateParams already set!");
2399 D->TemplateParams = Record.readTemplateParameterList();
2400 D->init(readDeclAs());
2401}
2402
2405 D->ConstraintExpr = Record.readExpr();
2407}
2408
2411
2412
2415 for (unsigned I = 0; I < D->NumTemplateArgs; ++I)
2416 Args.push_back(Record.readTemplateArgument(true));
2417 D->setTemplateArguments(Args);
2418}
2419
2421}
2422
2424 llvm::BitstreamCursor &DeclsCursor,
2425 bool IsPartial) {
2426 uint64_t Offset = ReadLocalOffset();
2427 bool Failed =
2428 Reader.ReadSpecializations(M, DeclsCursor, Offset, D, IsPartial);
2429 (void)Failed;
2430 assert(!Failed);
2431}
2432
2433RedeclarableResult
2436
2437
2438
2440 if (!CanonD->Common) {
2442 Reader.PendingDefinitions.insert(CanonD);
2443 }
2444 D->Common = CanonD->Common;
2445
2446
2447
2448 if (ThisDeclID == Redecl.getFirstID()) {
2449 if (auto *RTD = readDeclAs()) {
2450 assert(RTD->getKind() == D->getKind() &&
2451 "InstantiatedFromMemberTemplate kind mismatch");
2452 D->setInstantiatedFromMemberTemplate(RTD);
2453 if (Record.readInt())
2454 D->setMemberSpecialization();
2455 }
2456 }
2457
2460
2461 return Redecl;
2462}
2463
2467
2468 if (ThisDeclID == Redecl.getFirstID()) {
2469
2470
2473 }
2474
2475 if (D->getTemplatedDecl()->TemplateOrInstantiation) {
2476
2477
2478
2480 D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
2481 }
2482}
2483
2485 llvm_unreachable("BuiltinTemplates are not serialized");
2486}
2487
2488
2489
2490
2494
2495 if (ThisDeclID == Redecl.getFirstID()) {
2496
2497
2500 }
2501}
2502
2506
2508 if (Decl *InstD = readDecl()) {
2509 if (auto *CTD = dyn_cast(InstD)) {
2510 D->SpecializedTemplate = CTD;
2511 } else {
2513 Record.readTemplateArgumentList(TemplArgs);
2516 auto *PS =
2518 SpecializedPartialSpecialization();
2519 PS->PartialSpecialization
2520 = cast(InstD);
2521 PS->TemplateArgs = ArgList;
2522 D->SpecializedTemplate = PS;
2523 }
2524 }
2525
2527 Record.readTemplateArgumentList(TemplArgs, true);
2529 D->PointOfInstantiation = readSourceLocation();
2531
2532 bool writtenAsCanonicalDecl = Record.readInt();
2533 if (writtenAsCanonicalDecl) {
2534 auto *CanonPattern = readDeclAs();
2535 if (D->isCanonicalDecl()) {
2536
2538 if (auto *Partial = dyn_cast(D)) {
2539 CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
2540 .GetOrInsertNode(Partial);
2541 } else {
2542 CanonSpec =
2543 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2544 }
2545
2546 if (CanonSpec != D) {
2548
2549
2550
2551 if (auto *DDD = D->DefinitionData) {
2552 if (CanonSpec->DefinitionData)
2554 else
2555 CanonSpec->DefinitionData = D->DefinitionData;
2556 }
2557 D->DefinitionData = CanonSpec->DefinitionData;
2558 }
2559 }
2560 }
2561
2562
2563 if (Record.readBool()) {
2566 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();
2567 D->ExplicitInfo = ExplicitInfo;
2568 }
2569
2570 if (Record.readBool())
2571 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2572
2573 return Redecl;
2574}
2575
2578
2579
2581 D->TemplateParams = Params;
2582
2584
2585
2586 if (ThisDeclID == Redecl.getFirstID()) {
2587 D->InstantiatedFromMember.setPointer(
2588 readDeclAs());
2589 D->InstantiatedFromMember.setInt(Record.readInt());
2590 }
2591}
2592
2595
2596 if (ThisDeclID == Redecl.getFirstID()) {
2597
2599 }
2600}
2601
2602
2603
2604
2605
2606
2610 if (Decl *InstD = readDecl()) {
2611 if (auto *VTD = dyn_cast(InstD)) {
2612 D->SpecializedTemplate = VTD;
2613 } else {
2615 Record.readTemplateArgumentList(TemplArgs);
2617 C, TemplArgs);
2618 auto *PS =
2619 new (C)
2620 VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
2621 PS->PartialSpecialization =
2622 cast(InstD);
2623 PS->TemplateArgs = ArgList;
2624 D->SpecializedTemplate = PS;
2625 }
2626 }
2627
2628
2629 if (Record.readBool()) {
2632 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();
2633 D->ExplicitInfo = ExplicitInfo;
2634 }
2635
2636 if (Record.readBool())
2637 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2638
2640 Record.readTemplateArgumentList(TemplArgs, true);
2642 D->PointOfInstantiation = readSourceLocation();
2644 D->IsCompleteDefinition = Record.readInt();
2645
2647
2648 bool writtenAsCanonicalDecl = Record.readInt();
2649 if (writtenAsCanonicalDecl) {
2650 auto *CanonPattern = readDeclAs();
2651 if (D->isCanonicalDecl()) {
2653 if (auto *Partial = dyn_cast(D)) {
2654 CanonSpec = CanonPattern->getCommonPtr()
2655 ->PartialSpecializations.GetOrInsertNode(Partial);
2656 } else {
2657 CanonSpec =
2658 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2659 }
2660
2661 if (CanonSpec != D)
2663 }
2664 }
2665
2666 return Redecl;
2667}
2668
2669
2670
2671
2672
2673
2677 D->TemplateParams = Params;
2678
2680
2681
2682 if (ThisDeclID == Redecl.getFirstID()) {
2683 D->InstantiatedFromMember.setPointer(
2684 readDeclAs());
2685 D->InstantiatedFromMember.setInt(Record.readInt());
2686 }
2687}
2688
2691
2692 D->setDeclaredWithTypename(Record.readInt());
2693
2694 bool TypeConstraintInitialized = D->hasTypeConstraint() && Record.readBool();
2695 if (TypeConstraintInitialized) {
2697 if (Record.readBool())
2698 CR = Record.readConceptReference();
2699 Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
2700
2701 D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint);
2702 if ((D->ExpandedParameterPack = Record.readInt()))
2703 D->NumExpanded = Record.readInt();
2704 }
2705
2706 if (Record.readInt())
2707 D->setDefaultArgument(Reader.getContext(),
2708 Record.readTemplateArgumentLoc());
2709}
2710
2713
2714 D->setDepth(Record.readInt());
2715 D->setPosition(Record.readInt());
2716 if (D->hasPlaceholderTypeConstraint())
2717 D->setPlaceholderTypeConstraint(Record.readExpr());
2718 if (D->isExpandedParameterPack()) {
2719 auto TypesAndInfos =
2720 D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
2721 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2722 new (&TypesAndInfos[I].first) QualType(Record.readType());
2723 TypesAndInfos[I].second = readTypeSourceInfo();
2724 }
2725 } else {
2726
2727 D->ParameterPack = Record.readInt();
2728 if (Record.readInt())
2729 D->setDefaultArgument(Reader.getContext(),
2730 Record.readTemplateArgumentLoc());
2731 }
2732}
2733
2736 D->setDeclaredWithTypename(Record.readBool());
2737
2738 D->setDepth(Record.readInt());
2739 D->setPosition(Record.readInt());
2740 if (D->isExpandedParameterPack()) {
2742 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2743 I != N; ++I)
2744 Data[I] = Record.readTemplateParameterList();
2745 } else {
2746
2747 D->ParameterPack = Record.readInt();
2748 if (Record.readInt())
2749 D->setDefaultArgument(Reader.getContext(),
2750 Record.readTemplateArgumentLoc());
2751 }
2752}
2753
2757}
2758
2761 D->AssertExprAndFailed.setPointer(Record.readExpr());
2762 D->AssertExprAndFailed.setInt(Record.readInt());
2763 D->Message = cast_or_null(Record.readExpr());
2764 D->RParenLoc = readSourceLocation();
2765}
2766
2769}
2770
2774 D->ExtendingDecl = readDeclAs();
2775 D->ExprWithTemporary = Record.readStmt();
2776 if (Record.readInt()) {
2779 }
2780 D->ManglingNumber = Record.readInt();
2782}
2783
2785 uint64_t &VisibleOffset,
2786 uint64_t &ModuleLocalOffset,
2787 uint64_t &TULocalOffset) {
2788 LexicalOffset = ReadLocalOffset();
2789 VisibleOffset = ReadLocalOffset();
2790 ModuleLocalOffset = ReadLocalOffset();
2791 TULocalOffset = ReadLocalOffset();
2792}
2793
2794template
2797 Decl *MergeWith = nullptr;
2798
2799 bool IsKeyDecl = ThisDeclID == FirstDeclID;
2800 bool IsFirstLocalDecl = false;
2801
2802 uint64_t RedeclOffset = 0;
2803
2804
2805
2807 FirstDeclID = ThisDeclID;
2808 IsKeyDecl = true;
2809 IsFirstLocalDecl = true;
2810 } else if (unsigned N = Record.readInt()) {
2811
2812
2813 IsKeyDecl = N == 1;
2814 IsFirstLocalDecl = true;
2815
2816
2817
2818
2819
2820
2821 for (unsigned I = 0; I != N - 1; ++I)
2822 MergeWith = readDecl();
2823
2824 RedeclOffset = ReadLocalOffset();
2825 } else {
2826
2827
2828 (void)readDecl();
2829 }
2830
2831 auto *FirstDecl = cast_or_null(Reader.GetDecl(FirstDeclID));
2832 if (FirstDecl != D) {
2833
2834
2835
2836
2839 }
2840
2841 auto *DAsT = static_cast<T *>(D);
2842
2843
2844
2845
2846
2847 if (IsFirstLocalDecl)
2848 Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));
2849
2850 return RedeclarableResult(MergeWith, FirstDeclID, IsKeyDecl);
2851}
2852
2853
2854
2855template
2857 RedeclarableResult &Redecl) {
2858
2860 return;
2861
2862
2864 return;
2865
2866 auto *D = static_cast<T *>(DBase);
2867
2868 if (auto *Existing = Redecl.getKnownMergeTarget())
2869
2871 else if (FindExistingResult ExistingRes = findExisting(D))
2872 if (T *Existing = ExistingRes)
2874}
2875
2876
2877
2878
2879
2880
2881
2883 Decl &Context, unsigned IndexInContext) {
2884
2886 return;
2887
2888
2890 return;
2891
2892 if (auto *Existing = Redecl.getKnownMergeTarget())
2893
2895
2896
2897
2898 NamedDecl *&Slot = Reader.LambdaDeclarationsForMerging[{
2899 Context.getCanonicalDecl(), IndexInContext}];
2900 if (Slot)
2902 else
2903 Slot = D;
2904}
2905
2907 RedeclarableResult &Redecl) {
2909
2910
2911
2913}
2914
2915
2916
2917
2920 llvm_unreachable("bad assert_cast");
2921}
2922
2923
2924
2927 bool IsKeyDecl) {
2928 auto *DPattern = D->getTemplatedDecl();
2930 RedeclarableResult Result(
2931 ExistingPattern,
2932 DPattern->getCanonicalDecl()->getGlobalID(), IsKeyDecl);
2933
2934 if (auto *DClass = dyn_cast(DPattern)) {
2935
2936
2937 auto *ExistingClass =
2938 cast(ExistingPattern)->getCanonicalDecl();
2939 if (auto *DDD = DClass->DefinitionData) {
2940 if (ExistingClass->DefinitionData) {
2942 } else {
2943 ExistingClass->DefinitionData = DClass->DefinitionData;
2944
2945
2946 Reader.PendingDefinitions.insert(DClass);
2947 }
2948 }
2949 DClass->DefinitionData = ExistingClass->DefinitionData;
2950
2951 return mergeRedeclarable(DClass, cast(ExistingPattern),
2953 }
2954 if (auto *DFunction = dyn_cast(DPattern))
2955 return mergeRedeclarable(DFunction, cast(ExistingPattern),
2957 if (auto *DVar = dyn_cast(DPattern))
2959 if (auto *DAlias = dyn_cast(DPattern))
2960 return mergeRedeclarable(DAlias, cast(ExistingPattern),
2962 llvm_unreachable("merged an unknown kind of redeclarable template");
2963}
2964
2965
2966
2967template
2970 auto *D = static_cast<T *>(DBase);
2971 T *ExistingCanon = Existing->getCanonicalDecl();
2973 if (ExistingCanon != DCanon) {
2974
2975
2976
2978 D->First = ExistingCanon;
2979 ExistingCanon->Used |= D->Used;
2980 D->Used = false;
2981
2982 bool IsKeyDecl = KeyDeclID.isValid();
2983
2984
2985 if (auto *DTemplate = dyn_cast(D))
2987 DTemplate, assert_cast<RedeclarableTemplateDecl *>(ExistingCanon),
2988 IsKeyDecl);
2989
2990
2991 if (IsKeyDecl)
2992 Reader.KeyDecls[ExistingCanon].push_back(KeyDeclID);
2993 }
2994}
2995
2996
2997
2998
2999
3000
3002 if (!ND)
3003 return false;
3004
3005 if (isa<EnumConstantDecl, FieldDecl, IndirectFieldDecl>(ND))
3006 return true;
3007 return false;
3008}
3009
3010
3011
3013
3015 return;
3016
3018
3020 Reader.LETemporaryForMerging[std::make_pair(
3025 else
3027}
3028
3029
3030
3031
3032
3033template
3035
3037 return;
3038
3039
3040
3041
3042
3045 return;
3046
3047 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
3048 if (T *Existing = ExistingRes)
3050 Existing->getCanonicalDecl());
3051}
3052
3054 Record.readOMPChildren(D->Data);
3056}
3057
3059 Record.readOMPChildren(D->Data);
3061}
3062
3064 Record.readOMPChildren(D->Data);
3066}
3067
3073 D->setCombinerData(In, Out);
3075 D->setCombiner(Combiner);
3078 D->setInitializerData(Orig, Priv);
3081 D->setInitializer(Init, IK);
3082 D->PrevDeclInScope = readDeclID().getRawValue();
3083}
3084
3086 Record.readOMPChildren(D->Data);
3088 D->VarName = Record.readDeclarationName();
3089 D->PrevDeclInScope = readDeclID().getRawValue();
3090}
3091
3094}
3095
3096
3097
3098
3099
3100namespace {
3101class AttrReader {
3103
3104public:
3106
3107 uint64_t readInt() {
3108 return Reader.readInt();
3109 }
3110
3111 bool readBool() { return Reader.readBool(); }
3112
3115 }
3116
3119 }
3120
3121 Expr *readExpr() { return Reader.readExpr(); }
3122
3123 Attr *readAttr() { return Reader.readAttr(); }
3124
3125 std::string readString() {
3127 }
3128
3131 }
3132
3135 }
3136
3137 VersionTuple readVersionTuple() {
3139 }
3140
3142
3143 template T *readDeclAs() { return Reader.readDeclAs<T>(); }
3144};
3145}
3146
3148 AttrReader Record(*this);
3149 auto V = Record.readInt();
3150 if ()
3151 return nullptr;
3152
3153 Attr *New = nullptr;
3154
3155
3156 auto Kind = static_cast<attr::Kind>(V - 1);
3158
3163 unsigned ParsedKind = Record.readInt();
3164 unsigned Syntax = Record.readInt();
3165 unsigned SpellingIndex = Record.readInt();
3166 bool IsAlignas = (ParsedKind == AttributeCommonInfo::AT_Aligned &&
3168 SpellingIndex == AlignedAttr::Keyword_alignas);
3169 bool IsRegularKeywordAttribute = Record.readBool();
3170
3174 IsAlignas, IsRegularKeywordAttribute});
3175
3176#include "clang/Serialization/AttrPCHRead.inc"
3177
3178 assert(New && "Unable to decode attribute?");
3179 return New;
3180}
3181
3182
3184 for (unsigned I = 0, E = readInt(); I != E; ++I)
3186 Attrs.push_back(A);
3187}
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
3200 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
3201 DeclsLoaded[Index] = D;
3202}
3203
3204
3205
3206
3207
3208
3209
3210bool ASTReader::isConsumerInterestedIn(Decl *D) {
3211
3212
3213
3214
3215
3220 return false;
3221 }
3222
3225 return true;
3229 if (const auto *Var = dyn_cast(D))
3230 return Var->isFileVarDecl() &&
3232 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Var));
3233 if (const auto *Func = dyn_cast(D))
3234 return Func->doesThisDeclarationHaveABody() || PendingBodies.count(D);
3235
3238 return true;
3239
3240 return false;
3241}
3242
3243
3244ASTReader::RecordLocation ASTReader::DeclCursorForID(GlobalDeclID ID,
3247 assert(M);
3248 unsigned LocalDeclIndex = ID.getLocalDeclIndex();
3252}
3253
3254ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
3255 auto I = GlobalBitOffsetsMap.find(GlobalOffset);
3256
3257 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
3258 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
3259}
3260
3261uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset) {
3263}
3264
3266ASTDeclReader::getOrFakePrimaryClassDefinition(ASTReader &Reader,
3268
3269 auto *DD = RD->DefinitionData;
3270 if (!DD)
3272
3273
3274
3275
3276
3277 if (!DD) {
3278 DD = new (Reader.getContext()) struct CXXRecordDecl::DefinitionData(RD);
3280 RD->DefinitionData = DD;
3282
3283
3284 Reader.PendingFakeDefinitionData.insert(
3285 std::make_pair(DD, ASTReader::PendingFakeDefinitionKind::Fake));
3286 }
3287
3288 return DD->Definition;
3289}
3290
3291
3292
3295 if (auto *ND = dyn_cast(DC))
3296 return ND->getFirstDecl();
3297
3298 if (auto *RD = dyn_cast(DC))
3299 return getOrFakePrimaryClassDefinition(Reader, RD);
3300
3301 if (auto *RD = dyn_cast(DC))
3303
3304 if (auto *ED = dyn_cast(DC))
3306
3307 if (auto *OID = dyn_cast(DC))
3309
3310
3311
3312 if (auto *TU = dyn_cast(DC))
3314
3315 return nullptr;
3316}
3317
3318ASTDeclReader::FindExistingResult::~FindExistingResult() {
3319
3320
3321 if (TypedefNameForLinkage) {
3323 Reader.ImportedTypedefNamesForLinkage.insert(
3324 std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));
3325 return;
3326 }
3327
3328 if (!AddResult || Existing)
3329 return;
3330
3334 setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
3335 AnonymousDeclNumber, New);
3339 Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]
3340 .push_back(New);
3341 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
3342
3343
3344 MergeDC->makeDeclVisibleInContextImpl(New, true);
3345 }
3346}
3347
3348
3349
3350
3352 bool IsTypedefNameForLinkage) {
3353 if (!IsTypedefNameForLinkage)
3355
3356
3357
3358
3359 if (Found->isFromASTFile())
3360 return nullptr;
3361
3362 if (auto *TND = dyn_cast(Found))
3363 return TND->getAnonDeclWithTypedefName(true);
3364
3365 return nullptr;
3366}
3367
3368
3369
3370
3372ASTDeclReader::getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC) {
3373
3374 if (auto *RD = dyn_cast(LexicalDC)) {
3376 return DD ? DD->Definition : nullptr;
3377 } else if (auto *OID = dyn_cast(LexicalDC)) {
3378 return OID->getCanonicalDecl()->getDefinition();
3379 }
3380
3381
3382
3383
3385 if (auto *FD = dyn_cast(D))
3386 if (FD->isThisDeclarationADefinition())
3387 return FD;
3388 if (auto *MD = dyn_cast(D))
3389 if (MD->isThisDeclarationADefinition())
3390 return MD;
3391 if (auto *RD = dyn_cast(D))
3393 return RD;
3394 }
3395
3396
3397 return nullptr;
3398}
3399
3400NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
3402 unsigned Index) {
3403
3404
3406
3407
3408 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
3411
3412
3413
3414 auto *PrimaryDC = getPrimaryDCForAnonymousDecl(DC);
3415 if (PrimaryDC && !cast(PrimaryDC)->isFromASTFile()) {
3417 if (Previous.size() == Number)
3419 else
3421 });
3422 }
3423
3425}
3426
3427void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
3430 auto *CanonDC = cast(DC)->getCanonicalDecl();
3431
3432 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
3433 if (Index >= Previous.size())
3437}
3438
3439ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
3440 DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
3441 : D->getDeclName();
3442
3444
3445
3446 FindExistingResult Result(Reader, D, nullptr,
3447 AnonymousDeclNumber, TypedefNameForLinkage);
3450 }
3451
3454 if (TypedefNameForLinkage) {
3455 auto It = Reader.ImportedTypedefNamesForLinkage.find(
3456 std::make_pair(DC, TypedefNameForLinkage));
3457 if (It != Reader.ImportedTypedefNamesForLinkage.end())
3458 if (C.isSameEntity(It->second, D))
3459 return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
3460 TypedefNameForLinkage);
3461
3462
3463 }
3464
3466
3467
3468 if (auto *Existing = getAnonymousDeclForMerging(
3470 if (C.isSameEntity(Existing, D))
3471 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3472 TypedefNameForLinkage);
3476
3477
3478
3479 class UpToDateIdentifierRAII {
3481 bool WasOutToDate = false;
3482
3483 public:
3484 explicit UpToDateIdentifierRAII(IdentifierInfo *II) : II(II) {
3485 if (II) {
3487 if (WasOutToDate)
3489 }
3490 }
3491
3492 ~UpToDateIdentifierRAII() {
3493 if (WasOutToDate)
3495 }
3496 } UpToDate(Name.getAsIdentifierInfo());
3497
3499 IEnd = IdResolver.end();
3500 I != IEnd; ++I) {
3502 if (C.isSameEntity(Existing, D))
3503 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3504 TypedefNameForLinkage);
3505 }
3506 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
3510 if (C.isSameEntity(Existing, D))
3511 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3512 TypedefNameForLinkage);
3513 }
3514 } else {
3515
3516 return FindExistingResult(Reader);
3517 }
3518
3519
3520
3521
3522
3523
3524
3525
3526
3528 if (MergedDCIt != Reader.MergedDeclContexts.end() &&
3531 Reader.PendingOdrMergeChecks.push_back(D);
3532
3533 return FindExistingResult(Reader, D, nullptr,
3534 AnonymousDeclNumber, TypedefNameForLinkage);
3535}
3536
3537template
3539 return D->RedeclLink.getLatestNotUpdated();
3540}
3541
3543 llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");
3544}
3545
3547 assert(D);
3548
3550#define ABSTRACT_DECL(TYPE)
3551#define DECL(TYPE, BASE) \
3552 case Decl::TYPE: \
3553 return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
3554#include "clang/AST/DeclNodes.inc"
3555 }
3556 llvm_unreachable("unknown decl kind");
3557}
3558
3559Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
3561}
3562
3563namespace {
3567 const auto *IA = Previous->getAttr();
3568
3569 if (IA && ->hasAttr()) {
3570 NewAttr = cast(IA->clone(Context));
3573 }
3574
3575 const auto *AA = Previous->getAttr();
3576 if (AA && ->hasAttr()) {
3577 NewAttr = AA->clone(Context);
3580 }
3581}
3582}
3583
3584template
3588 D->RedeclLink.setPrevious(cast(Previous));
3589 D->First = cast(Previous)->First;
3590}
3591
3592namespace clang {
3593
3594template<>
3598 auto *VD = static_cast<VarDecl *>(D);
3599 auto *PrevVD = cast(Previous);
3600 D->RedeclLink.setPrevious(PrevVD);
3601 D->First = PrevVD->First;
3602
3603
3604
3605
3610 VD->demoteThisDefinitionToDeclaration();
3611 break;
3612 }
3613 }
3614 }
3615}
3616
3620}
3621
3622template<>
3627 auto *PrevFD = cast(Previous);
3628
3629 FD->RedeclLink.setPrevious(PrevFD);
3630 FD->First = PrevFD->First;
3631
3632
3633
3634 if (PrevFD->isInlined() != FD->isInlined()) {
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650 FD->setImplicitlyInline(true);
3651 }
3652
3655 if (FPT && PrevFPT) {
3656
3657
3659 bool WasUnresolved =
3661 if (IsUnresolved != WasUnresolved)
3662 Reader.PendingExceptionSpecUpdates.insert(
3663 {Canon, IsUnresolved ? PrevFD : FD});
3664
3665
3666
3669 if (IsUndeduced != WasUndeduced)
3670 Reader.PendingDeducedTypeUpdates.insert(
3671 {cast(Canon),
3672 (IsUndeduced ? PrevFPT : FPT)->getReturnType()});
3673 }
3674}
3675
3676}
3677
3679 llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
3680}
3681
3682
3683
3684template
3686 Decl *ToD) {
3687 auto *To = cast(ToD);
3688 if (!From->hasDefaultArgument())
3689 return false;
3690 To->setInheritedDefaultArgument(Context, From);
3691 return true;
3692}
3693
3699 assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");
3700
3701 for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {
3702 NamedDecl *FromParam = FromTP->getParam(I);
3703 NamedDecl *ToParam = ToTP->getParam(I);
3704
3705 if (auto *FTTP = dyn_cast(FromParam))
3707 else if (auto *FNTTP = dyn_cast(FromParam))
3709 else
3711 Context, cast(FromParam), ToParam);
3712 }
3713}
3714
3715
3716
3717
3721
3722
3724 return;
3725
3726
3727
3728
3729 if (!isa<VarDecl, FunctionDecl, TagDecl, RedeclarableTemplateDecl>(Previous))
3730 return;
3731
3732
3733
3734
3735
3736
3737 if (isa(Previous))
3738 return;
3739 if (isa(Previous))
3740 return;
3741 if (auto *Func = dyn_cast(Previous);
3742 Func && Func->getTemplateSpecializationInfo())
3743 return;
3744
3746 if (!M)
3747 return;
3748
3749
3751
3753 return;
3754
3757 return;
3758
3759 Reader.PendingWarningForDuplicatedDefsInModuleUnits.push_back(
3761 return;
3762 }
3763
3764
3766 return;
3767
3769 diag::err_multiple_decl_in_different_modules)
3772}
3773
3777
3779#define ABSTRACT_DECL(TYPE)
3780#define DECL(TYPE, BASE) \
3781 case Decl::TYPE: \
3782 attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
3783 break;
3784#include "clang/AST/DeclNodes.inc"
3785 }
3786
3788
3789
3790
3791
3792
3793
3795 Previous->IdentifierNamespace &
3797
3798
3799
3800 if (auto *TD = dyn_cast(D))
3802 cast(Previous), TD);
3803
3804
3805
3806
3807
3808 mergeInheritableAttributes(Reader, D, Previous);
3809}
3810
3811template
3813 D->RedeclLink.setLatest(cast(Latest));
3814}
3815
3817 llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
3818}
3819
3821 assert(D && Latest);
3822
3824#define ABSTRACT_DECL(TYPE)
3825#define DECL(TYPE, BASE) \
3826 case Decl::TYPE: \
3827 attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
3828 break;
3829#include "clang/AST/DeclNodes.inc"
3830 }
3831}
3832
3833template
3835 D->RedeclLink.markIncomplete();
3836}
3837
3839 llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
3840}
3841
3842void ASTReader::markIncompleteDeclChain(Decl *D) {
3844#define ABSTRACT_DECL(TYPE)
3845#define DECL(TYPE, BASE) \
3846 case Decl::TYPE: \
3847 ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
3848 break;
3849#include "clang/AST/DeclNodes.inc"
3850 }
3851}
3852
3853
3856 RecordLocation Loc = DeclCursorForID(ID, DeclLoc);
3857 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3858
3859
3861
3862 ReadingKindTracker ReadingKind(Read_Decl, *this);
3863
3864
3865 Deserializing ADecl(this);
3866
3867 auto Fail = [](const char *what, llvm::Error &&Err) {
3868 llvm::report_fatal_error(Twine("ASTReader::readDeclRecord failed ") + what +
3869 ": " + toString(std::move(Err)));
3870 };
3871
3872 if (llvm::Error JumpFailed = DeclsCursor.JumpToBit(Loc.Offset))
3873 Fail("jumping", std::move(JumpFailed));
3877 if (!MaybeCode)
3878 Fail("reading code", MaybeCode.takeError());
3879 unsigned Code = MaybeCode.get();
3880
3884 if (!MaybeDeclCode)
3885 llvm::report_fatal_error(
3886 Twine("ASTReader::readDeclRecord failed reading decl code: ") +
3887 toString(MaybeDeclCode.takeError()));
3888
3889 switch ((DeclCode)MaybeDeclCode.get()) {
3896 llvm_unreachable("Record cannot be de-serialized with readDeclRecord");
3899 break;
3902 break;
3905 break;
3908 break;
3911 break;
3914 break;
3917 break;
3920 break;
3923 break;
3926 break;
3929 break;
3932 break;
3935 break;
3938 break;
3941 break;
3944 break;
3947 break;
3950 break;
3953 break;
3956 break;
3959 break;
3962 break;
3965 break;
3968 break;
3971 break;
3974 break;
3977 break;
3980 break;
3983 break;
3986 break;
3989 break;
3992 break;
3995 break;
3998 break;
4001 break;
4004 break;
4006 bool HasTypeConstraint = Record.readInt();
4008 HasTypeConstraint);
4009 break;
4010 }
4012 bool HasTypeConstraint = Record.readInt();
4014 HasTypeConstraint);
4015 break;
4016 }
4018 bool HasTypeConstraint = Record.readInt();
4020 Context, ID, Record.readInt(), HasTypeConstraint);
4021 break;
4022 }
4025 break;
4029 break;
4032 break;
4035 break;
4038 break;
4041 break;
4044 break;
4047 break;
4050 break;
4053 break;
4056 break;
4059 break;
4062 break;
4065 break;
4068 break;
4071 break;
4074 break;
4077 break;
4080 break;
4083 break;
4086 break;
4089 break;
4092 break;
4095 break;
4098 break;
4101 break;
4104 break;
4107 break;
4109 D = MSGuidDecl::CreateDeserialized(Context, ID);
4110 break;
4112 D = UnnamedGlobalConstantDecl::CreateDeserialized(Context, ID);
4113 break;
4115 D = TemplateParamObjectDecl::CreateDeserialized(Context, ID);
4116 break;
4119 break;
4122 break;
4124 Error("attempt to read a C++ base-specifier record as a declaration");
4125 return nullptr;
4127 Error("attempt to read a C++ ctor initializer record as a declaration");
4128 return nullptr;
4130
4131
4133 break;
4136 unsigned NumChildren = Record.readInt();
4139 break;
4140 }
4142 unsigned NumClauses = Record.readInt();
4143 unsigned NumVars = Record.readInt();
4146 break;
4147 }
4149 unsigned NumClauses = Record.readInt();
4152 break;
4153 }
4156 break;
4158 unsigned NumClauses = Record.readInt();
4161 break;
4162 }
4165 break;
4168 break;
4172 break;
4175 break;
4178 break;
4181 break;
4184 break;
4188 break;
4189 }
4190
4191 assert(D && "Unknown declaration reading AST file");
4192 LoadedDecl(translateGlobalDeclIDToIndex(ID), D);
4193
4194
4195
4197
4198
4200
4201
4202
4203 if (auto *DC = dyn_cast(D)) {
4206 uint64_t ModuleLocalOffset = 0;
4208
4209 Reader.VisitDeclContext(DC, LexicalOffset, VisibleOffset, ModuleLocalOffset,
4210 TULocalOffset);
4211
4212
4213
4214
4215 if (!LexicalOffset && !VisibleOffset && !ModuleLocalOffset &&
4216 isa(D))
4217 if (auto Iter = DelayedNamespaceOffsetMap.find(ID);
4218 Iter != DelayedNamespaceOffsetMap.end()) {
4219 LexicalOffset = Iter->second.LexicalOffset;
4220 VisibleOffset = Iter->second.VisibleOffset;
4221 ModuleLocalOffset = Iter->second.ModuleLocalOffset;
4222 TULocalOffset = Iter->second.TULocalOffset;
4223 }
4224
4225 if (LexicalOffset &&
4226 ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, LexicalOffset, DC))
4227 return nullptr;
4228 if (VisibleOffset && ReadVisibleDeclContextStorage(
4229 *Loc.F, DeclsCursor, VisibleOffset, ID,
4230 VisibleDeclContextStorageKind::GenerallyVisible))
4231 return nullptr;
4232 if (ModuleLocalOffset &&
4233 ReadVisibleDeclContextStorage(
4234 *Loc.F, DeclsCursor, ModuleLocalOffset, ID,
4235 VisibleDeclContextStorageKind::ModuleLocalVisible))
4236 return nullptr;
4237 if (TULocalOffset && ReadVisibleDeclContextStorage(
4238 *Loc.F, DeclsCursor, TULocalOffset, ID,
4239 VisibleDeclContextStorageKind::TULocalVisible))
4240 return nullptr;
4241 }
4243
4244
4245 PendingUpdateRecords.push_back(
4246 PendingUpdateRecord(ID, D, true));
4247
4248
4249 if (auto *Class = dyn_cast(D))
4250
4251
4252 if (Class->isThisDeclarationADefinition() ||
4253 PendingDefinitions.count(Class))
4254 loadObjCCategories(ID, Class);
4255
4256
4257
4258
4259
4260 PotentiallyInterestingDecls.push_back(D);
4261
4262 return D;
4263}
4264
4265void ASTReader::PassInterestingDeclsToConsumer() {
4266 assert(Consumer);
4267
4268 if (PassingDeclsToConsumer)
4269 return;
4270
4271
4272
4273 SaveAndRestore GuardPassingDeclsToConsumer(PassingDeclsToConsumer, true);
4274
4275
4276
4277 for (auto ID : EagerlyDeserializedDecls)
4279 EagerlyDeserializedDecls.clear();
4280
4281 auto ConsumingPotentialInterestingDecls = [this]() {
4282 while (!PotentiallyInterestingDecls.empty()) {
4283 Decl *D = PotentiallyInterestingDecls.front();
4284 PotentiallyInterestingDecls.pop_front();
4285 if (isConsumerInterestedIn(D))
4286 PassInterestingDeclToConsumer(D);
4287 }
4288 };
4289 std::deque<Decl *> MaybeInterestingDecls =
4290 std::move(PotentiallyInterestingDecls);
4291 PotentiallyInterestingDecls.clear();
4292 assert(PotentiallyInterestingDecls.empty());
4293 while (!MaybeInterestingDecls.empty()) {
4294 Decl *D = MaybeInterestingDecls.front();
4295 MaybeInterestingDecls.pop_front();
4296
4297
4298
4299
4300
4301 if (auto *VD = dyn_cast(D);
4302 VD && VD->isFileVarDecl() && !VD->isExternallyVisible())
4303 VD->getInit();
4304 ConsumingPotentialInterestingDecls();
4305 if (isConsumerInterestedIn(D))
4306 PassInterestingDeclToConsumer(D);
4307 }
4308
4309
4310 ConsumingPotentialInterestingDecls();
4311
4313 auto *RD = cast(GetDecl(ID));
4315 PassVTableToConsumer(RD);
4316 }
4317 VTablesToEmit.clear();
4318}
4319
4320void ASTReader::loadDeclUpdateRecords(PendingUpdateRecord &Record) {
4321
4322
4323
4326 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
4327 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
4328
4329 if (UpdI != DeclUpdateOffsets.end()) {
4330 auto UpdateOffsets = std::move(UpdI->second);
4331 DeclUpdateOffsets.erase(UpdI);
4332
4333
4334
4335
4336
4337 bool WasInteresting = Record.JustLoaded || isConsumerInterestedIn(D);
4338 for (auto &FileAndOffset : UpdateOffsets) {
4339 ModuleFile *F = FileAndOffset.first;
4340 uint64_t Offset = FileAndOffset.second;
4343 if (llvm::Error JumpFailed = Cursor.JumpToBit(Offset))
4344
4345 llvm::report_fatal_error(
4346 Twine("ASTReader::loadDeclUpdateRecords failed jumping: ") +
4347 toString(std::move(JumpFailed)));
4349 if (!MaybeCode)
4350 llvm::report_fatal_error(
4351 Twine("ASTReader::loadDeclUpdateRecords failed reading code: ") +
4352 toString(MaybeCode.takeError()));
4353 unsigned Code = MaybeCode.get();
4356 assert(MaybeRecCode.get() == DECL_UPDATES &&
4357 "Expected DECL_UPDATES record!");
4358 else
4359 llvm::report_fatal_error(
4360 Twine("ASTReader::loadDeclUpdateRecords failed reading rec code: ") +
4361 toString(MaybeCode.takeError()));
4362
4365 Reader.UpdateDecl(D);
4366
4367
4368
4369 if (!WasInteresting && isConsumerInterestedIn(D)) {
4370 PotentiallyInterestingDecls.push_back(D);
4371 WasInteresting = true;
4372 }
4373 }
4374 }
4375
4376
4377 if (auto I = PendingVisibleUpdates.find(ID);
4378 I != PendingVisibleUpdates.end()) {
4379 auto VisibleUpdates = std::move(I->second);
4380 PendingVisibleUpdates.erase(I);
4381
4383 for (const auto &Update : VisibleUpdates)
4384 Lookups[DC].Table.add(
4388 }
4389
4390 if (auto I = PendingModuleLocalVisibleUpdates.find(ID);
4391 I != PendingModuleLocalVisibleUpdates.end()) {
4392 auto ModuleLocalVisibleUpdates = std::move(I->second);
4393 PendingModuleLocalVisibleUpdates.erase(I);
4394
4396 for (const auto &Update : ModuleLocalVisibleUpdates)
4397 ModuleLocalLookups[DC].Table.add(
4400
4401
4403 }
4404
4405 if (auto I = TULocalUpdates.find(ID); I != TULocalUpdates.end()) {
4406 auto Updates = std::move(I->second);
4407 TULocalUpdates.erase(I);
4408
4410 for (const auto &Update : Updates)
4411 TULocalLookups[DC].Table.add(
4415 }
4416
4417
4419 if (auto IT = RelatedDeclsMap.find(ID); IT != RelatedDeclsMap.end()) {
4420 for (auto LID : IT->second)
4422 RelatedDeclsMap.erase(IT);
4423 }
4424 }
4425
4426
4427 if (auto I = PendingSpecializationsUpdates.find(ID);
4428 I != PendingSpecializationsUpdates.end()) {
4429 auto SpecializationUpdates = std::move(I->second);
4430 PendingSpecializationsUpdates.erase(I);
4431
4432 for (const auto &Update : SpecializationUpdates)
4433 AddSpecializations(D, Update.Data, *Update.Mod, false);
4434 }
4435
4436
4437 if (auto I = PendingPartialSpecializationsUpdates.find(ID);
4438 I != PendingPartialSpecializationsUpdates.end()) {
4439 auto SpecializationUpdates = std::move(I->second);
4440 PendingPartialSpecializationsUpdates.erase(I);
4441
4442 for (const auto &Update : SpecializationUpdates)
4443 AddSpecializations(D, Update.Data, *Update.Mod, true);
4444 }
4445}
4446
4447void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {
4448
4450 if (FirstLocal != CanonDecl) {
4453 *this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,
4454 CanonDecl);
4455 }
4456
4457 if (!LocalOffset) {
4459 return;
4460 }
4461
4462
4464 assert(M && "imported decl from no module file");
4465
4468 if (llvm::Error JumpFailed = Cursor.JumpToBit(LocalOffset))
4469 llvm::report_fatal_error(
4470 Twine("ASTReader::loadPendingDeclChain failed jumping: ") +
4471 toString(std::move(JumpFailed)));
4472
4475 if (!MaybeCode)
4476 llvm::report_fatal_error(
4477 Twine("ASTReader::loadPendingDeclChain failed reading code: ") +
4478 toString(MaybeCode.takeError()));
4479 unsigned Code = MaybeCode.get();
4482 "expected LOCAL_REDECLARATIONS record!");
4483 else
4484 llvm::report_fatal_error(
4485 Twine("ASTReader::loadPendingDeclChain failed reading rec code: ") +
4486 toString(MaybeCode.takeError()));
4487
4488
4489
4490 Decl *MostRecent = FirstLocal;
4491 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
4492 unsigned Idx = N - I - 1;
4495 MostRecent = D;
4496 }
4498}
4499
4500namespace {
4501
4502
4503
4504 class ObjCCategoriesVisitor {
4507 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
4509 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
4511 unsigned PreviousGeneration;
4512
4514
4515 if (!Deserialized.erase(Cat))
4516 return;
4517
4518
4526 NonEquivalentDecls, StructuralEquivalenceKind::Default,
4527 false,
4528 false,
4529 true);
4530 if (!Ctx.IsEquivalent(Cat, Existing)) {
4531
4532 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
4535 diag::note_previous_definition);
4536 }
4537 } else if (!Existing) {
4538
4539 Existing = Cat;
4540 }
4541 }
4542
4543
4544 if (Tail)
4546 else
4547 Interface->setCategoryListRaw(Cat);
4548 Tail = Cat;
4549 }
4550
4551 public:
4552 ObjCCategoriesVisitor(
4554 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
4555 GlobalDeclID InterfaceID, unsigned PreviousGeneration)
4557 InterfaceID(InterfaceID), PreviousGeneration(PreviousGeneration) {
4558
4559 for (auto *Cat : Interface->known_categories()) {
4561 NameCategoryMap[Cat->getDeclName()] = Cat;
4562
4563
4564 Tail = Cat;
4565 }
4566 }
4567
4569
4570
4571 if (M.Generation <= PreviousGeneration)
4572 return true;
4573
4574
4575
4576
4580 return true;
4581
4582
4583
4588 Compare);
4590 LocalID != Result->getDefinitionID()) {
4591
4592
4593
4595 }
4596
4597
4598 unsigned Offset = Result->Offset;
4600 M.ObjCCategories[Offset++] = 0;
4601 for (unsigned I = 0; I != N; ++I)
4603 return true;
4604 }
4605 };
4606
4607}
4608
4610 unsigned PreviousGeneration) {
4611 ObjCCategoriesVisitor Visitor(*this, D, CategoriesDeserialized, ID,
4612 PreviousGeneration);
4613 ModuleMgr.visit(Visitor);
4614}
4615
4616template<typename DeclT, typename Fn>
4618 F(D);
4619
4620
4621
4622
4624 bool Found = false;
4625 for (auto *Redecl = MostRecent; Redecl && ;
4626 Redecl = Redecl->getPreviousDecl())
4628
4629
4631 for (auto *Redecl = MostRecent; Redecl != D;
4633 F(Redecl);
4634 }
4635}
4636
4641 auto *RD = cast(D);
4643 assert(MD && "couldn't read decl from update record");
4644 Reader.PendingAddedClassMembers.push_back({RD, MD});
4645 break;
4646 }
4647
4649 auto *Anon = readDeclAs();
4650
4651
4652
4653
4654 if (.isModule()) {
4655 if (auto *TU = dyn_cast(D))
4656 TU->setAnonymousNamespace(Anon);
4657 else
4658 cast(D)->setAnonymousNamespace(Anon);
4659 }
4660 break;
4661 }
4662
4664 auto *VD = cast(D);
4665 VD->NonParmVarDeclBits.IsInline = Record.readInt();
4666 VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
4668 break;
4669 }
4670
4673 if (auto *VTSD = dyn_cast(D)) {
4674 VTSD->setPointOfInstantiation(POI);
4675 } else if (auto *VD = dyn_cast(D)) {
4677 assert(MSInfo && "No member specialization information");
4679 } else {
4680 auto *FD = cast(D);
4681 if (auto *FTSInfo = FD->TemplateOrSpecialization
4683 FTSInfo->setPointOfInstantiation(POI);
4684 else
4685 cast<MemberSpecializationInfo *>(FD->TemplateOrSpecialization)
4686 ->setPointOfInstantiation(POI);
4687 }
4688 break;
4689 }
4690
4692 auto *Param = cast(D);
4693
4694
4695
4696
4697 auto *DefaultArg = Record.readExpr();
4698
4699
4700
4701 if (Param->hasUninstantiatedDefaultArg())
4702 Param->setDefaultArg(DefaultArg);
4703 break;
4704 }
4705
4707 auto *FD = cast(D);
4708 auto *DefaultInit = Record.readExpr();
4709
4710
4711
4712 if (FD->hasInClassInitializer() && !FD->hasNonNullInClassInitializer()) {
4713 if (DefaultInit)
4714 FD->setInClassInitializer(DefaultInit);
4715 else
4716
4717
4718 FD->removeInClassInitializer();
4719 }
4720 break;
4721 }
4722
4724 auto *FD = cast(D);
4725 if (Reader.PendingBodies[FD]) {
4726
4727
4728 return;
4729 }
4730
4731 if (Record.readInt()) {
4732
4733
4734
4737 });
4738 }
4739 FD->setInnerLocStart(readSourceLocation());
4741 assert(Record.getIdx() == Record.size() && "lazy body must be last");
4742 break;
4743 }
4744
4746 auto *RD = cast(D);
4748 bool HadRealDefinition =
4749 OldDD && (OldDD->Definition != RD ||
4750 !Reader.PendingFakeDefinitionData.count(OldDD));
4754 ReadCXXRecordDefinition(RD, true);
4755
4756
4757 uint64_t LexicalOffset = ReadLocalOffset();
4758 if (!HadRealDefinition && LexicalOffset) {
4759 Record.readLexicalDeclContextStorage(LexicalOffset, RD);
4760 Reader.PendingFakeDefinitionData.erase(OldDD);
4761 }
4762
4767 MSInfo->setTemplateSpecializationKind(TSK);
4768 MSInfo->setPointOfInstantiation(POI);
4769 } else {
4770 auto *Spec = cast(RD);
4771 Spec->setTemplateSpecializationKind(TSK);
4772 Spec->setPointOfInstantiation(POI);
4773
4774 if (Record.readInt()) {
4775 auto *PartialSpec =
4776 readDeclAs();
4778 Record.readTemplateArgumentList(TemplArgs);
4781
4782
4783
4784 if (!isa<ClassTemplatePartialSpecializationDecl *>(
4785 Spec->getSpecializedTemplateOrPartial()))
4786 Spec->setInstantiationOf(PartialSpec, TemplArgList);
4787 }
4788 }
4789
4794
4795 if (Record.readInt()) {
4797 Record.readAttributes(Attrs);
4798
4799
4801 D->setAttrsImpl(Attrs, Reader.getContext());
4802 }
4803 break;
4804 }
4805
4807
4808
4809 auto *Del = readDeclAs();
4811 auto *ThisArg = Record.readExpr();
4812
4813 if (->OperatorDelete) {
4814 First->OperatorDelete = Del;
4815 First->OperatorDeleteThisArg = ThisArg;
4816 }
4817 break;
4818 }
4819
4822 auto ESI = Record.readExceptionSpecInfo(ExceptionStorage);
4823
4824
4825 auto *FD = cast(D);
4827
4828
4831 FPT->getReturnType(), FPT->getParamTypes(),
4832 FPT->getExtProtoInfo().withExceptionSpec(ESI)));
4833
4834
4835
4836 Reader.PendingExceptionSpecUpdates.insert(
4837 std::make_pair(FD->getCanonicalDecl(), FD));
4838 }
4839 break;
4840 }
4841
4843 auto *FD = cast(D);
4845 Reader.PendingDeducedTypeUpdates.insert(
4846 {FD->getCanonicalDecl(), DeducedResultType});
4847 break;
4848 }
4849
4851
4853 break;
4854
4858 break;
4859
4863 break;
4864
4866 D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(Reader.getContext(),
4867 readSourceRange()));
4868 break;
4869
4871 auto AllocatorKind =
4872 static_castOMPAllocateDeclAttr::AllocatorTypeTy\(Record.readInt());
4873 Expr *Allocator = Record.readExpr();
4874 Expr *Alignment = Record.readExpr();
4876 D->addAttr(OMPAllocateDeclAttr::CreateImplicit(
4877 Reader.getContext(), AllocatorKind, Allocator, Alignment, SR));
4878 break;
4879 }
4880
4882 unsigned SubmoduleID = readSubmoduleID();
4883 auto *Exported = cast(D);
4886 Reader.PendingMergedDefinitionsToDeduplicate.insert(Exported);
4887 break;
4888 }
4889
4891 auto MapType = Record.readEnumOMPDeclareTargetDeclAttr::MapTypeTy();
4892 auto DevType = Record.readEnumOMPDeclareTargetDeclAttr::DevTypeTy();
4893 Expr *IndirectE = Record.readExpr();
4895 unsigned Level = Record.readInt();
4896 D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit(
4898 readSourceRange()));
4899 break;
4900 }
4901
4904 Record.readAttributes(Attrs);
4905 assert(Attrs.size() == 1);
4907 break;
4908 }
4909 }
4910}
This file provides AST data structures related to concepts.
Defines the clang::ASTContext interface.
static T assert_cast(T t)
"Cast" to type T, asserting if we don't have an implicit conversion.
static bool allowODRLikeMergeInC(NamedDecl *ND)
ODR-like semantics for C/ObjC allow us to merge tag types and a structural check in Sema guarantees t...
static NamedDecl * getDeclForMerging(NamedDecl *Found, bool IsTypedefNameForLinkage)
Find the declaration that should be merged into, given the declaration found by name lookup.
static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From, Decl *ToD)
Inherit the default template argument from From to To.
static void inheritDefaultTemplateArguments(ASTContext &Context, TemplateDecl *From, TemplateDecl *To)
static void forAllLaterRedecls(DeclT *D, Fn F)
static llvm::iterator_range< MergedRedeclIterator< DeclT > > merged_redecls(DeclT *D)
Defines the clang::attr::Kind enum.
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines OpenMP nodes for declarative directives.
Defines the C++ template declaration subclasses.
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
Defines several types used to describe C++ lambda expressions that are shared between the parser and ...
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
This file defines OpenMP AST classes for clauses.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
Defines utilities for dealing with stack allocation and stack space.
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
bool needsCleanup() const
Returns whether the object performed allocations.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template.
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
const LangOptions & getLangOpts() const
void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst, UsingEnumDecl *Pattern)
Remember that the using enum decl Inst is an instantiation of the using enum decl Pattern of a class ...
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
void addOverriddenMethod(const CXXMethodDecl *Method, const CXXMethodDecl *Overridden)
Note that the given C++ Method overrides the given Overridden method.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
void * Allocate(size_t Size, unsigned Align=8) const
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy initialization expression of a block var decl.
void addDestruction(T *Ptr) const
If T isn't trivially destructible, calls AddDeallocation to register it for destruction.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
void mergeDefinitionIntoModule(NamedDecl *ND, Module *M, bool NotifyListeners=true)
Note that the definition ND has been merged into module M, and should be visible whenever M is visibl...
void setPrimaryMergedDecl(Decl *D, Decl *Primary)
void setObjCMethodRedeclaration(const ObjCMethodDecl *MD, const ObjCMethodDecl *Redecl)
bool isInSameModule(const Module *M1, const Module *M2)
If the two module M1 and M2 are in the same module.
void mergeTemplatePattern(RedeclarableTemplateDecl *D, RedeclarableTemplateDecl *Existing, bool IsKeyDecl)
Merge together the pattern declarations from two template declarations.
ASTDeclMerger(ASTReader &Reader)
void mergeRedeclarable(Redeclarable< T > *D, T *Existing, RedeclarableResult &Redecl)
void mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl, Decl &Context, unsigned Number)
Attempt to merge D with a previous declaration of the same lambda, which is found by its index within...
void MergeDefinitionData(CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&NewDD)
void mergeRedeclarableImpl(Redeclarable< T > *D, T *Existing, GlobalDeclID KeyDeclID)
Attempts to merge the given declaration (D) with another declaration of the same entity.
void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D)
void VisitObjCImplementationDecl(ObjCImplementationDecl *D)
void mergeRedeclarableTemplate(RedeclarableTemplateDecl *D, RedeclarableResult &Redecl)
void VisitImportDecl(ImportDecl *D)
void VisitBindingDecl(BindingDecl *BD)
void VisitNamespaceDecl(NamespaceDecl *D)
void VisitTopLevelStmtDecl(TopLevelStmtDecl *D)
RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D)
void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D)
void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D)
void ReadFunctionDefinition(FunctionDecl *FD)
void VisitLabelDecl(LabelDecl *LD)
void VisitObjCCategoryDecl(ObjCCategoryDecl *D)
void VisitUsingDirectiveDecl(UsingDirectiveDecl *D)
RedeclarableResult VisitClassTemplateSpecializationDeclImpl(ClassTemplateSpecializationDecl *D)
void VisitFunctionDecl(FunctionDecl *FD)
void VisitObjCMethodDecl(ObjCMethodDecl *D)
void VisitUsingShadowDecl(UsingShadowDecl *D)
void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D)
void VisitVarDecl(VarDecl *VD)
RedeclarableResult VisitRedeclarable(Redeclarable< T > *D)
void VisitMSGuidDecl(MSGuidDecl *D)
void VisitPragmaCommentDecl(PragmaCommentDecl *D)
void VisitRecordDecl(RecordDecl *RD)
void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D)
void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D)
void ReadVarDeclInit(VarDecl *VD)
static Decl * getMostRecentDeclImpl(Redeclarable< DeclT > *D)
void VisitNamespaceAliasDecl(NamespaceAliasDecl *D)
void VisitIndirectFieldDecl(IndirectFieldDecl *FD)
void VisitObjCContainerDecl(ObjCContainerDecl *D)
void VisitBlockDecl(BlockDecl *BD)
void VisitExportDecl(ExportDecl *D)
static void attachLatestDecl(Decl *D, Decl *latest)
void VisitStaticAssertDecl(StaticAssertDecl *D)
void VisitEmptyDecl(EmptyDecl *D)
void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D)
void VisitValueDecl(ValueDecl *VD)
void VisitEnumDecl(EnumDecl *ED)
void mergeRedeclarable(Redeclarable< T > *D, RedeclarableResult &Redecl)
Attempts to merge the given declaration (D) with another declaration of the same entity.
void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D)
void VisitFriendTemplateDecl(FriendTemplateDecl *D)
void VisitObjCProtocolDecl(ObjCProtocolDecl *D)
void VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D)
void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D)
void VisitDeclaratorDecl(DeclaratorDecl *DD)
RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD)
void VisitFriendDecl(FriendDecl *D)
void VisitLinkageSpecDecl(LinkageSpecDecl *D)
void VisitCXXRecordDecl(CXXRecordDecl *D)
ASTDeclReader(ASTReader &Reader, ASTRecordReader &Record, ASTReader::RecordLocation Loc, GlobalDeclID thisDeclID, SourceLocation ThisDeclLoc)
void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD)
void VisitImplicitConceptSpecializationDecl(ImplicitConceptSpecializationDecl *D)
void VisitNamedDecl(NamedDecl *ND)
void mergeMergeable(Mergeable< T > *D)
Attempts to merge the given declaration (D) with another declaration of the same entity,...
void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D)
static Decl * getMostRecentDecl(Decl *D)
void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D)
void VisitCXXConstructorDecl(CXXConstructorDecl *D)
void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D)
void VisitImplicitParamDecl(ImplicitParamDecl *PD)
void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D)
static void setNextObjCCategory(ObjCCategoryDecl *Cat, ObjCCategoryDecl *Next)
void VisitMSPropertyDecl(MSPropertyDecl *FD)
void VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D)
void VisitFieldDecl(FieldDecl *FD)
RedeclarableResult VisitVarDeclImpl(VarDecl *D)
void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D)
void VisitCapturedDecl(CapturedDecl *CD)
void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D)
void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D)
RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D)
void VisitAccessSpecDecl(AccessSpecDecl *D)
void VisitCXXMethodDecl(CXXMethodDecl *D)
void VisitOMPAllocateDecl(OMPAllocateDecl *D)
void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D)
static void attachLatestDeclImpl(Redeclarable< DeclT > *D, Decl *Latest)
static void markIncompleteDeclChainImpl(Redeclarable< DeclT > *D)
RedeclarableResult VisitTagDecl(TagDecl *TD)
ObjCTypeParamList * ReadObjCTypeParamList()
void VisitHLSLBufferDecl(HLSLBufferDecl *D)
void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D)
void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *GD)
void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D)
void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D)
static void checkMultipleDefinitionInNamedModules(ASTReader &Reader, Decl *D, Decl *Previous)
void VisitUsingEnumDecl(UsingEnumDecl *D)
void VisitObjCImplDecl(ObjCImplDecl *D)
void VisitTranslationUnitDecl(TranslationUnitDecl *TU)
void VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset, uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset, uint64_t &TULocalOffset)
void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D)
void VisitTypeDecl(TypeDecl *TD)
void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D)
void VisitEnumConstantDecl(EnumConstantDecl *ECD)
void VisitTypeAliasDecl(TypeAliasDecl *TD)
static void attachPreviousDeclImpl(ASTReader &Reader, Redeclarable< DeclT > *D, Decl *Previous, Decl *Canon)
void VisitConceptDecl(ConceptDecl *D)
void VisitObjCPropertyDecl(ObjCPropertyDecl *D)
void VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D)
void VisitObjCIvarDecl(ObjCIvarDecl *D)
void VisitUsingPackDecl(UsingPackDecl *D)
void VisitFunctionTemplateDecl(FunctionTemplateDecl *D)
void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D)
RedeclarableResult VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D)
TODO: Unify with ClassTemplateSpecializationDecl version? May require unifying ClassTemplate(Partial)...
void VisitUsingDecl(UsingDecl *D)
void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D)
void VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D)
TODO: Unify with ClassTemplatePartialSpecializationDecl version? May require unifying ClassTemplate(P...
void VisitParmVarDecl(ParmVarDecl *PD)
void VisitVarTemplateDecl(VarTemplateDecl *D)
TODO: Unify with ClassTemplateDecl version? May require unifying ClassTemplateDecl and VarTemplateDec...
static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous, Decl *Canon)
void VisitClassTemplateDecl(ClassTemplateDecl *D)
void VisitCXXDestructorDecl(CXXDestructorDecl *D)
void VisitTemplateDecl(TemplateDecl *D)
void VisitCXXConversionDecl(CXXConversionDecl *D)
void VisitTypedefDecl(TypedefDecl *TD)
void VisitOMPRequiresDecl(OMPRequiresDecl *D)
RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD)
void VisitDecompositionDecl(DecompositionDecl *DD)
void ReadSpecializations(ModuleFile &M, Decl *D, llvm::BitstreamCursor &DeclsCursor, bool IsPartial)
Reads an AST files chain containing the contents of a translation unit.
bool isDeclIDFromModule(GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
DiagnosticBuilder Diag(unsigned DiagID) const
Report a diagnostic.
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Decl * ReadDecl(ModuleFile &F, const RecordDataImpl &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
ModuleFile * getOwningModuleFile(const Decl *D) const
Retrieve the module file that owns the given declaration, or NULL if the declaration is not from a mo...
T * ReadDeclAs(ModuleFile &F, const RecordDataImpl &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
SourceLocation ReadSourceLocation(ModuleFile &MF, RawLocEncoding Raw, LocSeq *Seq=nullptr) const
Read a source location from raw form.
LocalDeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, GlobalDeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
QualType GetType(serialization::TypeID ID)
Resolve a type ID into a type, potentially building a new type.
IdentifierResolver & getIdResolver()
Get the identifier resolver used for name lookup / updates in the translation unit scope.
Decl * GetDecl(GlobalDeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef)
Note that MergedDef is a redefinition of the canonical definition Def, so Def should be visible whene...
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
SmallVector< uint64_t, 64 > RecordData
An object for streaming information from a record.
bool readBool()
Read a boolean value, advancing Idx.
std::string readString()
Read a string, advancing Idx.
void readAttributes(AttrVec &Attrs)
Reads attributes from the current stream position, advancing Idx.
T * readDeclAs()
Reads a declaration from the given position in the record, advancing Idx.
IdentifierInfo * readIdentifier()
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
TypeSourceInfo * readTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
SourceRange readSourceRange(LocSeq *Seq=nullptr)
Read a source range, advancing Idx.
OMPTraitInfo * readOMPTraitInfo()
Read an OMPTraitInfo object, advancing Idx.
VersionTuple readVersionTuple()
Read a version tuple, advancing Idx.
uint64_t readInt()
Returns the current value in this record, and advances to the next value.
Attr * readAttr()
Reads one attribute from the current stream position, advancing Idx.
Expr * readExpr()
Reads an expression.
SourceLocation readSourceLocation(LocSeq *Seq=nullptr)
Read a source location, advancing Idx.
Represents an access specifier followed by colon ':'.
static AccessSpecDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Attr - This represents one attribute.
Attr * clone(ASTContext &C) const
Syntax
The style used to specify an attribute.
@ AS_Keyword
__ptr16, alignas(...), etc.
A binding in a decomposition declaration.
static BindingDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
A simple helper class to unpack an integer to bits and consuming the bits in order.
uint32_t getNextBits(uint32_t Width)
A class which contains all the information about a particular captured value.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
void setDoesNotEscape(bool B=true)
void setSignatureAsWritten(TypeSourceInfo *Sig)
void setCanAvoidCopyToHeap(bool B=true)
void setIsConversionFromLambda(bool val=true)
void setBlockMissingReturnType(bool val=true)
static BlockDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setIsVariadic(bool value)
void setBody(CompoundStmt *B)
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Represents a C++ constructor within a class.
static CXXConstructorDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, uint64_t AllocKind)
Represents a C++ conversion function within a class.
static CXXConversionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a C++ deduction guide declaration.
static CXXDeductionGuideDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a C++ destructor within a class.
static CXXDestructorDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a static or instance method of a struct/union/class.
static CXXMethodDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a C++ struct/union/class.
CXXRecordDecl * getDefinition() const
static CXXRecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents the body of a CapturedStmt, and serves as its DeclContext.
static CapturedDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)
void setContextParam(unsigned i, ImplicitParamDecl *P)
void setNothrow(bool Nothrow=true)
void setParam(unsigned i, ImplicitParamDecl *P)
Declaration of a class template.
static ClassTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Create an empty class template node.
static ClassTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a class template specialization, which refers to a class template with a given set of temp...
static ClassTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Declaration of a C++20 concept.
static ConceptDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
A reference to a concept and its template args, as it appears in the code.
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
static ConstructorUsingShadowDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
void setHasExternalVisibleStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations visible in this context.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
bool isFunctionOrMethod() const
DeclID getRawValue() const
A simple visitor class that helps create declaration visitors.
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
ASTContext & getASTContext() const LLVM_READONLY
void setOwningModuleID(unsigned ID)
Set the owning module ID.
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
void setTopLevelDeclInObjCContainer(bool V=true)
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
ObjCDeclQualifier
ObjCDeclQualifier - 'Qualifiers' written next to the return and parameter types in method declaration...
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
bool isInvalidDecl() const
unsigned FromASTFile
Whether this declaration was loaded from an AST file.
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
@ IDNS_Ordinary
Ordinary names.
@ IDNS_Type
Types, declared with 'struct foo', typedefs, etc.
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
void setImplicit(bool I=true)
void setReferenced(bool R=true)
void setLocation(SourceLocation L)
DeclContext * getDeclContext()
void setCachedLinkage(Linkage L) const
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
ModuleOwnershipKind
The kind of ownership a declaration has, for visibility purposes.
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
@ Unowned
This declaration is not owned by a module.
@ ReachableWhenImported
This declaration has an owning module, and is visible to lookups that occurs within that module.
@ ModulePrivate
This declaration has an owning module, but is only visible to lookups that occur within that module.
@ Visible
This declaration has an owning module, but is globally visible (typically because its owning module i...
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
bool shouldEmitInExternalSource() const
Whether the definition of the declaration should be emitted in external sources.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
The name of a declaration.
Selector getObjCSelector() const
Get the Objective-C selector stored in this declaration name.
Represents a ValueDecl that came out of a declarator.
void setInnerLocStart(SourceLocation L)
void setTypeSourceInfo(TypeSourceInfo *TI)
TypeSourceInfo * getTypeSourceInfo() const
A decomposition declaration.
static DecompositionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumBindings)
Represents an empty-declaration.
static EmptyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
An instance of this object exists for each enum constant that is defined.
static EnumConstantDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setInitExpr(Expr *E)
void setInitVal(const ASTContext &C, const llvm::APSInt &V)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
void setFixed(bool Fixed=true)
True if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying type.
void setIntegerType(QualType T)
Set the underlying integer type.
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
static EnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setScoped(bool Scoped=true)
True if this tag declaration is a scoped enumeration.
void setPromotionType(QualType T)
Set the promotion type.
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
void setScopedUsingClassTag(bool ScopedUCT=true)
If this tag declaration is a scoped enum, then this is true if the scoped enum was declared using the...
Represents a standard C++ module export declaration.
static ExportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
This represents one expression.
Represents a member of a struct/union/class.
void setBitWidth(Expr *Width)
Set the bit-field width for this member.
static FieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
const VariableArrayType * CapturedVLAType
void setRParenLoc(SourceLocation L)
void setAsmString(StringLiteral *Asm)
static FileScopeAsmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
static FriendDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned FriendTypeNumTPLists)
Declaration of a friend template.
static FriendTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Represents a function declaration or definition.
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
void setHasSkippedBody(bool Skipped=true)
static FunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setUsesSEHTry(bool UST)
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
void setHasWrittenPrototype(bool P=true)
State that this function has a written prototype.
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
void setDefaultLoc(SourceLocation NewLoc)
void setInlineSpecified(bool I)
Set whether the "inline" keyword was specified for this function.
TemplatedKind
The kind of templated function a FunctionDecl can be.
@ TK_MemberSpecialization
@ TK_DependentNonTemplate
@ TK_FunctionTemplateSpecialization
@ TK_DependentFunctionTemplateSpecialization
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
void setInstantiatedFromDecl(FunctionDecl *FD)
Specify that this function declaration was instantiated from a FunctionDecl FD.
bool isDeletedAsWritten() const
void setHasInheritedPrototype(bool P=true)
State that this function inherited its prototype from a previous declaration.
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
void setLateTemplateParsed(bool ILT=true)
State that this templated function will be late parsed.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
void setTrivialForCall(bool IT)
bool isDefaulted() const
Whether this function is defaulted.
void setIneligibleOrNotSelected(bool II)
void setConstexprKind(ConstexprSpecKind CSK)
void setDefaulted(bool D=true)
void setStorageClass(StorageClass SClass)
Sets the storage class as written in the source.
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
void setExplicitlyDefaulted(bool ED=true)
State that this function is explicitly defaulted.
void setHasImplicitReturnZero(bool IRZ)
State that falling off this function implicitly returns null/zero.
Represents a prototype with parameter type info, e.g.
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Declaration of a template function.
static FunctionTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Create an empty function template node.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, MemberSpecializationInfo *MSInfo)
void Profile(llvm::FoldingSetNodeID &ID)
FunctionDecl * getFunction() const
Retrieve the declaration of the function template specialization.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
static HLSLBufferDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
One of these records is kept for each identifier that is lexed.
void setOutOfDate(bool OOD)
Set whether the information for this identifier is out of date with respect to the external source.
bool isOutOfDate() const
Determine whether the information for this identifier is out of date with respect to the external sou...
iterator - Iterate over the decls of a specified declaration name.
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
iterator begin(DeclarationName Name)
Returns an iterator over decls with the name 'Name'.
bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)
Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn't alre...
iterator end()
Returns the end iterator.
static ImplicitConceptSpecializationDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID, unsigned NumTemplateArgs)
static ImplicitParamDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Describes a module import declaration, which makes the contents of the named module visible in the cu...
static ImportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumLocations)
Create a new, deserialized module import declaration.
Represents a field injected from an anonymous union/struct into the parent scope.
static IndirectFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setInherited(bool I)
Description of a constructor that was inherited from a base class.
Represents the declaration of a label.
static LabelDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Describes the capture of a variable or of this, or of a C++1y init-capture.
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
unsigned getManglingNumber() const
static LifetimeExtendedTemporaryDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
ValueDecl * getExtendingDecl()
Represents a linkage specification.
static LinkageSpecDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents the results of name lookup.
An instance of this class represents the declaration of a property member.
static MSPropertyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Provides information a specialization of a member of a class template, which may be a member function...
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...
Describes a module or submodule.
@ AllVisible
All of the names in this module are visible.
std::string Name
The name of this module.
bool isGlobalModule() const
Does this Module scope describe a fragment of the global module within some C++ module.
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
bool isNamedModule() const
Does this Module is a named module of a standard named module?
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
bool isPlaceholderVar(const LangOptions &LangOpts) const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
void setDeclName(DeclarationName N)
Set the name of this declaration.
Represents a C++ namespace alias.
static NamespaceAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represent a C++ namespace.
static NamespaceDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
static NonTypeTemplateParmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, bool HasTypeConstraint)
This represents '#pragma omp allocate ...' directive.
static OMPAllocateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NVars, unsigned NClauses)
Pseudo declaration for capturing expressions.
static OMPCapturedExprDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
This represents '#pragma omp declare mapper ...' directive.
static OMPDeclareMapperDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)
Creates deserialized declare mapper node.
This represents '#pragma omp declare reduction ...' directive.
static OMPDeclareReductionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Create deserialized declare reduction node.
This represents '#pragma omp requires...' directive.
static OMPRequiresDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)
Create deserialized requires node.
This represents '#pragma omp threadprivate ...' directive.
static OMPThreadPrivateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
Represents a field declaration created by an @defs(...).
static ObjCAtDefsFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
ObjCCategoryDecl - Represents a category declaration.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
static ObjCCategoryDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setIvarLBraceLoc(SourceLocation Loc)
void setCategoryNameLoc(SourceLocation Loc)
void setIvarRBraceLoc(SourceLocation Loc)
bool IsClassExtension() const
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
static ObjCCategoryImplDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
ObjCCompatibleAliasDecl - Represents alias of a class.
static ObjCCompatibleAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setClassInterface(ObjCInterfaceDecl *D)
ObjCContainerDecl - Represents a container for method declarations.
void setAtStartLoc(SourceLocation Loc)
void setAtEndRange(SourceRange atEnd)
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
static ObjCImplementationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents an ObjC class declaration.
void mergeClassExtensionProtocolList(ObjCProtocolDecl *const *List, unsigned Num, ASTContext &C)
mergeClassExtensionProtocolList - Merge class extension's protocol list into the protocol list for th...
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
static ObjCInterfaceDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCIvarDecl - Represents an ObjC instance variable.
void setAccessControl(AccessControl ac)
void setNextIvar(ObjCIvarDecl *ivar)
ObjCInterfaceDecl * getContainingInterface()
Return the class interface that this ivar is logically contained in; this is either the interface whe...
void setSynthesize(bool synth)
static ObjCIvarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
ObjCMethodDecl - Represents an instance or class method declaration.
void setSynthesizedAccessorStub(bool isSynthesizedAccessorStub)
void setObjCDeclQualifier(ObjCDeclQualifier QV)
void setDefined(bool isDefined)
void setSelfDecl(ImplicitParamDecl *SD)
void setReturnTypeSourceInfo(TypeSourceInfo *TInfo)
void setHasRedeclaration(bool HRD) const
void setIsRedeclaration(bool RD)
void setCmdDecl(ImplicitParamDecl *CD)
bool hasRedeclaration() const
True if redeclared in the same interface.
void setRelatedResultType(bool RRT=true)
Note whether this method has a related result type.
void setOverriding(bool IsOver)
void setPropertyAccessor(bool isAccessor)
void setDeclImplementation(ObjCImplementationControl ic)
void setReturnType(QualType T)
static ObjCMethodDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setHasSkippedBody(bool Skipped=true)
void setInstanceMethod(bool isInst)
void setVariadic(bool isVar)
Represents one property declaration in an Objective-C interface.
static ObjCPropertyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
static ObjCPropertyImplDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents an Objective-C protocol declaration.
static ObjCProtocolDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
ObjCProtocolDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C protocol.
Represents the declaration of an Objective-C type parameter.
static ObjCTypeParamDecl * CreateDeserialized(ASTContext &ctx, GlobalDeclID ID)
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
Represents a partial function definition.
static OutlinedFunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)
Represents a parameter to a function.
static ParmVarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setUninstantiatedDefaultArg(Expr *arg)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
void setObjCMethodScopeInfo(unsigned parameterIndex)
Represents a #pragma detect_mismatch line.
static PragmaDetectMismatchDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NameValueSize)
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtrOrNull() const
Represents a struct/union/class.
unsigned getODRHash()
Get precomputed ODRHash or add a new one.
void setAnonymousStructOrUnion(bool Anon)
void setArgPassingRestrictions(RecordArgPassingKind Kind)
void setNonTrivialToPrimitiveCopy(bool V)
void setHasNonTrivialToPrimitiveCopyCUnion(bool V)
void setHasNonTrivialToPrimitiveDestructCUnion(bool V)
void setHasFlexibleArrayMember(bool V)
void setParamDestroyedInCallee(bool V)
void setNonTrivialToPrimitiveDestroy(bool V)
void setHasObjectMember(bool val)
void setHasVolatileMember(bool val)
void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V)
static RecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
void setHasUninitializedExplicitInitFields(bool V)
void setNonTrivialToPrimitiveDefaultInitialize(bool V)
Declaration of a redeclarable template.
CommonBase * Common
Pointer to the common data shared by all declarations of this template.
virtual CommonBase * newCommon(ASTContext &C) const =0
Provides common interface for the Decls that can be redeclared.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
static DeclLink PreviousDeclLink(decl_type *D)
Represents the body of a requires-expression.
static RequiresExprBodyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
const FunctionDecl * getKernelEntryPointDecl() const
Encodes a location in the source.
A trivial tuple used to represent a source range.
Represents a C++11 static_assert declaration.
static StaticAssertDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
StringLiteral - This represents a string literal expression, e.g.
Represents the declaration of a struct/union/class/enum.
void setTagKind(TagKind TK)
void setCompleteDefinitionRequired(bool V=true)
True if this complete decl is required to be complete for some existing use.
void demoteThisDefinitionToDeclaration()
Mark a definition as a declaration and maintain information it was a definition.
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
void setFreeStanding(bool isFreeStanding=true)
True if this tag is free standing, e.g. "struct foo;".
void setBraceRange(SourceRange R)
void setCompleteDefinition(bool V=true)
True if this decl has its body fully specified.
A convenient class for passing around template argument information.
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
The base class of all kinds of template declarations (e.g., class, function, etc.).
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
A template parameter object.
Stores a list of template parameters for a TemplateDecl and its derived classes.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
static TemplateTemplateParmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Declaration of a template type parameter.
static TemplateTypeParmDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
A declaration that models statements at global scope.
static TopLevelStmtDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
static TypeAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Declaration of an alias template.
static TypeAliasTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Create an empty alias template node.
Represents a declaration of a type.
void setLocStart(SourceLocation L)
A container of type source information.
QualType getType() const
Return the type wrapped by this type source info.
const T * castAs() const
Member-template castAs.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
const T * getAs() const
Member-template getAs'.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Base class for declarations which introduce a typedef-name.
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
void setTypeSourceInfo(TypeSourceInfo *newType)
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
void addDecl(NamedDecl *D)
A set of unresolved declarations.
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
static UnresolvedUsingIfExistsDecl * CreateDeserialized(ASTContext &Ctx, GlobalDeclID ID)
Represents a dependent using declaration which was marked with typename.
static UnresolvedUsingTypenameDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a dependent using declaration which was not marked with typename.
static UnresolvedUsingValueDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a C++ using-declaration.
static UsingDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents C++ using-directive.
static UsingDirectiveDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a C++ using-enum-declaration.
static UsingEnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a pack of using declarations that a single using-declarator pack-expanded into.
static UsingPackDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumExpansions)
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
static UsingShadowDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
ParmVarDeclBitfields ParmVarDeclBits
static VarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
VarDeclBitfields VarDeclBits
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form,...
NonParmVarDeclBitfields NonParmVarDeclBits
@ Definition
This declaration is definitely a definition.
void setDescribedVarTemplate(VarTemplateDecl *Template)
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Declaration of a variable template.
static VarTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Create an empty variable template node.
static VarTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents a variable template specialization, which refers to a variable template with a given set o...
static VarTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Source location and bit offset of a declaration.
RawLocEncoding getRawLoc() const
uint64_t getBitOffset(const uint64_t DeclTypesBlockStartOffset) const
Information about a module that has been loaded by the ASTReader.
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID.
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
uint64_t GlobalBitOffset
The global bit offset (or base) of this module.
const DeclOffset * DeclOffsets
Offset of each declaration within the bitstream, indexed by the declaration ID (-1).
unsigned Generation
The generation of which this module file is a part.
uint64_t DeclsBlockStartOffset
The offset to the start of the DECLTYPES_BLOCK block.
SmallVector< uint64_t, 1 > ObjCCategories
The Objective-C category lists for categories known to this module.
void visit(llvm::function_ref< bool(ModuleFile &M)> Visitor, llvm::SmallPtrSetImpl< ModuleFile * > *ModuleFilesHit=nullptr)
Visit each of the modules.
Class that performs name lookup into a DeclContext stored in an AST file.
const unsigned int LOCAL_REDECLARATIONS
Record code for a list of local redeclarations of a declaration.
DeclCode
Record codes for each kind of declaration.
const unsigned int DECL_UPDATES
Record of updates for a declaration that was modified after being deserialized.
@ DECL_EMPTY
An EmptyDecl record.
@ DECL_CAPTURED
A CapturedDecl record.
@ DECL_CXX_BASE_SPECIFIERS
A record containing CXXBaseSpecifiers.
@ DECL_CXX_RECORD
A CXXRecordDecl record.
@ DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION
A VarTemplatePartialSpecializationDecl record.
@ DECL_OMP_ALLOCATE
An OMPAllocateDcl record.
@ DECL_MS_PROPERTY
A MSPropertyDecl record.
@ DECL_OMP_DECLARE_MAPPER
An OMPDeclareMapperDecl record.
@ DECL_TOP_LEVEL_STMT_DECL
A TopLevelStmtDecl record.
@ DECL_REQUIRES_EXPR_BODY
A RequiresExprBodyDecl record.
@ DECL_STATIC_ASSERT
A StaticAssertDecl record.
@ DECL_INDIRECTFIELD
A IndirectFieldDecl record.
@ DECL_TEMPLATE_TEMPLATE_PARM
A TemplateTemplateParmDecl record.
@ DECL_IMPORT
An ImportDecl recording a module import.
@ DECL_UNNAMED_GLOBAL_CONSTANT
A UnnamedGlobalConstantDecl record.
@ DECL_ACCESS_SPEC
An AccessSpecDecl record.
@ DECL_OBJC_TYPE_PARAM
An ObjCTypeParamDecl record.
@ DECL_OBJC_CATEGORY_IMPL
A ObjCCategoryImplDecl record.
@ DECL_ENUM_CONSTANT
An EnumConstantDecl record.
@ DECL_PARM_VAR
A ParmVarDecl record.
@ DECL_TYPEDEF
A TypedefDecl record.
@ DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK
A TemplateTemplateParmDecl record that stores an expanded template template parameter pack.
@ DECL_HLSL_BUFFER
A HLSLBufferDecl record.
@ DECL_NAMESPACE_ALIAS
A NamespaceAliasDecl record.
@ DECL_TYPEALIAS
A TypeAliasDecl record.
@ DECL_FUNCTION_TEMPLATE
A FunctionTemplateDecl record.
@ DECL_MS_GUID
A MSGuidDecl record.
@ DECL_UNRESOLVED_USING_TYPENAME
An UnresolvedUsingTypenameDecl record.
@ DECL_CLASS_TEMPLATE_SPECIALIZATION
A ClassTemplateSpecializationDecl record.
@ DECL_FILE_SCOPE_ASM
A FileScopeAsmDecl record.
@ DECL_PARTIAL_SPECIALIZATIONS
@ DECL_CXX_CONSTRUCTOR
A CXXConstructorDecl record.
@ DECL_CXX_CONVERSION
A CXXConversionDecl record.
@ DECL_FIELD
A FieldDecl record.
@ DECL_LINKAGE_SPEC
A LinkageSpecDecl record.
@ DECL_CONTEXT_TU_LOCAL_VISIBLE
A record that stores the set of declarations that are only visible to the TU.
@ DECL_NAMESPACE
A NamespaceDecl record.
@ DECL_NON_TYPE_TEMPLATE_PARM
A NonTypeTemplateParmDecl record.
@ DECL_USING_PACK
A UsingPackDecl record.
@ DECL_FUNCTION
A FunctionDecl record.
@ DECL_USING_DIRECTIVE
A UsingDirecitveDecl record.
@ DECL_RECORD
A RecordDecl record.
@ DECL_CONTEXT_LEXICAL
A record that stores the set of declarations that are lexically stored within a given DeclContext.
@ DECL_OUTLINEDFUNCTION
A OutlinedFunctionDecl record.
@ DECL_BLOCK
A BlockDecl record.
@ DECL_UNRESOLVED_USING_VALUE
An UnresolvedUsingValueDecl record.
@ DECL_TYPE_ALIAS_TEMPLATE
A TypeAliasTemplateDecl record.
@ DECL_CXX_CTOR_INITIALIZERS
A record containing CXXCtorInitializers.
@ DECL_OBJC_CATEGORY
A ObjCCategoryDecl record.
@ DECL_VAR
A VarDecl record.
@ DECL_UNRESOLVED_USING_IF_EXISTS
An UnresolvedUsingIfExistsDecl record.
@ DECL_USING
A UsingDecl record.
@ DECL_OBJC_PROTOCOL
A ObjCProtocolDecl record.
@ DECL_TEMPLATE_TYPE_PARM
A TemplateTypeParmDecl record.
@ DECL_VAR_TEMPLATE_SPECIALIZATION
A VarTemplateSpecializationDecl record.
@ DECL_OBJC_IMPLEMENTATION
A ObjCImplementationDecl record.
@ DECL_LABEL
A LabelDecl record.
@ DECL_OBJC_COMPATIBLE_ALIAS
A ObjCCompatibleAliasDecl record.
@ DECL_CONSTRUCTOR_USING_SHADOW
A ConstructorUsingShadowDecl record.
@ DECL_USING_ENUM
A UsingEnumDecl record.
@ DECL_FRIEND_TEMPLATE
A FriendTemplateDecl record.
@ DECL_PRAGMA_DETECT_MISMATCH
A PragmaDetectMismatchDecl record.
@ DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK
A NonTypeTemplateParmDecl record that stores an expanded non-type template parameter pack.
@ DECL_OBJC_AT_DEFS_FIELD
A ObjCAtDefsFieldDecl record.
@ DECL_IMPLICIT_PARAM
An ImplicitParamDecl record.
@ DECL_FRIEND
A FriendDecl record.
@ DECL_CXX_METHOD
A CXXMethodDecl record.
@ DECL_EXPORT
An ExportDecl record.
@ DECL_BINDING
A BindingDecl record.
@ DECL_PRAGMA_COMMENT
A PragmaCommentDecl record.
@ DECL_ENUM
An EnumDecl record.
@ DECL_CONTEXT_MODULE_LOCAL_VISIBLE
A record containing the set of declarations that are only visible from DeclContext in the same module...
@ DECL_DECOMPOSITION
A DecompositionDecl record.
@ DECL_OMP_DECLARE_REDUCTION
An OMPDeclareReductionDecl record.
@ DECL_OMP_THREADPRIVATE
An OMPThreadPrivateDecl record.
@ DECL_OBJC_METHOD
A ObjCMethodDecl record.
@ DECL_CXX_DESTRUCTOR
A CXXDestructorDecl record.
@ DECL_OMP_CAPTUREDEXPR
An OMPCapturedExprDecl record.
@ DECL_CLASS_TEMPLATE
A ClassTemplateDecl record.
@ DECL_USING_SHADOW
A UsingShadowDecl record.
@ DECL_CONCEPT
A ConceptDecl record.
@ DECL_CXX_DEDUCTION_GUIDE
A CXXDeductionGuideDecl record.
@ DECL_OMP_REQUIRES
An OMPRequiresDecl record.
@ DECL_OBJC_IVAR
A ObjCIvarDecl record.
@ DECL_OBJC_PROPERTY
A ObjCPropertyDecl record.
@ DECL_TEMPLATE_PARAM_OBJECT
A TemplateParamObjectDecl record.
@ DECL_OBJC_INTERFACE
A ObjCInterfaceDecl record.
@ DECL_VAR_TEMPLATE
A VarTemplateDecl record.
@ DECL_LIFETIME_EXTENDED_TEMPORARY
An LifetimeExtendedTemporaryDecl record.
@ DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION
A ClassTemplatePartialSpecializationDecl record.
@ DECL_IMPLICIT_CONCEPT_SPECIALIZATION
An ImplicitConceptSpecializationDecl record.
@ DECL_CONTEXT_VISIBLE
A record that stores the set of declarations that are visible from a given DeclContext.
@ DECL_OBJC_PROPERTY_IMPL
A ObjCPropertyImplDecl record.
Defines the Linkage enumeration and various utility functions.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
ComparisonCategoryResult Compare(const T &X, const T &Y)
Helper to compare two comparable types.
uint64_t TypeID
An ID number that refers to a type in an AST file.
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
void numberAnonymousDeclsWithin(const DeclContext *DC, Fn Visit)
Visit each declaration within DC that needs an anonymous declaration number and call Visit with the d...
bool isPartOfPerModuleInitializer(const Decl *D)
Determine whether the given declaration will be included in the per-module initializer if it needs to...
@ UPD_CXX_RESOLVED_DTOR_DELETE
@ UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER
@ UPD_CXX_DEDUCED_RETURN_TYPE
@ UPD_CXX_ADDED_IMPLICIT_MEMBER
@ UPD_DECL_MARKED_OPENMP_DECLARETARGET
@ UPD_CXX_POINT_OF_INSTANTIATION
@ UPD_CXX_RESOLVED_EXCEPTION_SPEC
@ UPD_CXX_ADDED_FUNCTION_DEFINITION
@ UPD_DECL_MARKED_OPENMP_THREADPRIVATE
@ UPD_STATIC_LOCAL_NUMBER
@ UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT
@ UPD_ADDED_ATTR_TO_RECORD
@ UPD_DECL_MARKED_OPENMP_ALLOCATE
@ UPD_CXX_ADDED_ANONYMOUS_NAMESPACE
@ UPD_CXX_INSTANTIATED_CLASS_DEFINITION
@ UPD_CXX_ADDED_VAR_DEFINITION
The JSON file list parser is used to communicate input to InstallAPI.
SelectorLocationsKind
Whether all locations of the selector identifiers are in a "standard" position.
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
ConstexprSpecKind
Define the kind of constexpr specifier.
LinkageSpecLanguageIDs
Represents the language in a linkage specification.
LazyOffsetPtr< Stmt, uint64_t, &ExternalASTSource::GetExternalDeclStmt > LazyDeclStmtPtr
A lazy pointer to a statement.
LambdaCaptureKind
The different capture forms in a lambda introducer.
@ LCK_ByCopy
Capturing by copy (a.k.a., by value)
@ LCK_ByRef
Capturing by reference.
@ LCK_VLAType
Capturing variable-length array type.
@ LCK_StarThis
Capturing the *this object by copy.
@ LCK_This
Capturing the *this object by reference.
OMPDeclareReductionInitKind
StorageClass
Storage classes.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ None
No linkage, which means that the entity is unique and can only be referred to from within its scope.
@ Result
The result type of a method or function.
TagTypeKind
The kind of a tag type.
ObjCImplementationControl
RecordArgPassingKind
Enum that represents the different ways arguments are passed to and returned from function calls.
static bool isUndeducedReturnType(QualType T)
bool operator!=(CanQual< T > x, CanQual< U > y)
for(const auto &A :T->param_types())
const FunctionProtoType * T
DeductionCandidate
Only used by CXXDeductionGuideDecl.
bool shouldSkipCheckingODR(const Decl *D)
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Other
Other implicit parameter.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Structure used to store a statement, the constant value to which it was evaluated (if any),...
bool HasConstantDestruction
Whether this variable is known to have constant destruction.
bool WasEvaluated
Whether this statement was already evaluated.
bool HasConstantInitialization
Whether this variable is known to have constant initialization.
Provides information about an explicit instantiation of a variable or class template.
SourceLocation ExternKeywordLoc
The location of the extern keyword.
Data that is common to all of the declarations of a given function template.
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations
The function template specializations for this function template, including explicit specializations ...
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
Helper class that saves the current stream position and then restores it when destroyed.
llvm::DenseSet< std::tuple< Decl *, Decl *, int > > NonEquivalentDeclSet
Store declaration pairs already found to be non-equivalent.
Describes the categories of an Objective-C class.