96#include "llvm/ADT/APFloat.h"
97#include "llvm/ADT/APInt.h"
98#include "llvm/ADT/APSInt.h"
99#include "llvm/ADT/ArrayRef.h"
100#include "llvm/ADT/DenseMap.h"
101#include "llvm/ADT/FloatingPointMode.h"
102#include "llvm/ADT/FoldingSet.h"
103#include "llvm/ADT/Hashing.h"
104#include "llvm/ADT/IntrusiveRefCntPtr.h"
105#include "llvm/ADT/STLExtras.h"
106#include "llvm/ADT/ScopeExit.h"
107#include "llvm/ADT/SmallPtrSet.h"
108#include "llvm/ADT/SmallString.h"
109#include "llvm/ADT/SmallVector.h"
110#include "llvm/ADT/StringExtras.h"
111#include "llvm/ADT/StringMap.h"
112#include "llvm/ADT/StringRef.h"
113#include "llvm/ADT/iterator_range.h"
114#include "llvm/Bitstream/BitstreamReader.h"
115#include "llvm/Support/Casting.h"
116#include "llvm/Support/Compiler.h"
117#include "llvm/Support/Compression.h"
118#include "llvm/Support/DJB.h"
119#include "llvm/Support/Endian.h"
120#include "llvm/Support/Error.h"
121#include "llvm/Support/ErrorHandling.h"
122#include "llvm/Support/FileSystem.h"
123#include "llvm/Support/LEB128.h"
124#include "llvm/Support/MemoryBuffer.h"
125#include "llvm/Support/Path.h"
126#include "llvm/Support/SaveAndRestore.h"
127#include "llvm/Support/TimeProfiler.h"
128#include "llvm/Support/Timer.h"
129#include "llvm/Support/VersionTuple.h"
130#include "llvm/Support/raw_ostream.h"
131#include "llvm/TargetParser/Triple.h"
144#include <system_error>
149using namespace clang;
152using llvm::BitstreamCursor;
160 return First->ReadFullVersionInformation(FullVersion) ||
161 Second->ReadFullVersionInformation(FullVersion);
165 First->ReadModuleName(ModuleName);
166 Second->ReadModuleName(ModuleName);
170 First->ReadModuleMapFile(ModuleMapPath);
171 Second->ReadModuleMapFile(ModuleMapPath);
177 bool AllowCompatibleDifferences) {
178 return First->ReadLanguageOptions(LangOpts, Complain,
179 AllowCompatibleDifferences) ||
180 Second->ReadLanguageOptions(LangOpts, Complain,
181 AllowCompatibleDifferences);
186 bool AllowCompatibleDifferences) {
187 return First->ReadTargetOptions(TargetOpts, Complain,
188 AllowCompatibleDifferences) ||
189 Second->ReadTargetOptions(TargetOpts, Complain,
190 AllowCompatibleDifferences);
195 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
196 Second->ReadDiagnosticOptions(DiagOpts, Complain);
202 return First->ReadFileSystemOptions(FSOpts, Complain) ||
203 Second->ReadFileSystemOptions(FSOpts, Complain);
209 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
211 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
217 std::string &SuggestedPredefines) {
218 return First->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
219 SuggestedPredefines) ||
220 Second->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
221 SuggestedPredefines);
226 First->ReadCounter(M,
Value);
227 Second->ReadCounter(M,
Value);
231 return First->needsInputFileVisitation() ||
232 Second->needsInputFileVisitation();
236 return First->needsSystemInputFileVisitation() ||
237 Second->needsSystemInputFileVisitation();
242 First->visitModuleFile(
Filename, Kind);
243 Second->visitModuleFile(
Filename, Kind);
249 bool isExplicitModule) {
250 bool Continue =
false;
251 if (First->needsInputFileVisitation() &&
252 (!isSystem || First->needsSystemInputFileVisitation()))
253 Continue |= First->visitInputFile(
Filename, isSystem, isOverridden,
255 if (Second->needsInputFileVisitation() &&
256 (!isSystem || Second->needsSystemInputFileVisitation()))
257 Continue |= Second->visitInputFile(
Filename, isSystem, isOverridden,
264 First->readModuleFileExtension(Metadata);
265 Second->readModuleFileExtension(Metadata);
285 bool AllowCompatibleDifferences =
true) {
286#define LANGOPT(Name, Bits, Default, Description) \
287 if (ExistingLangOpts.Name != LangOpts.Name) { \
290 Diags->Report(diag::err_pch_langopt_mismatch) \
291 << Description << LangOpts.Name << ExistingLangOpts.Name; \
293 Diags->Report(diag::err_pch_langopt_value_mismatch) \
299#define VALUE_LANGOPT(Name, Bits, Default, Description) \
300 if (ExistingLangOpts.Name != LangOpts.Name) { \
302 Diags->Report(diag::err_pch_langopt_value_mismatch) \
307#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
308 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
310 Diags->Report(diag::err_pch_langopt_value_mismatch) \
315#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
316 if (!AllowCompatibleDifferences) \
317 LANGOPT(Name, Bits, Default, Description)
319#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
320 if (!AllowCompatibleDifferences) \
321 ENUM_LANGOPT(Name, Bits, Default, Description)
323#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
324 if (!AllowCompatibleDifferences) \
325 VALUE_LANGOPT(Name, Bits, Default, Description)
327#define BENIGN_LANGOPT(Name, Bits, Default, Description)
328#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
329#define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description)
330#include "clang/Basic/LangOptions.def"
334 Diags->
Report(diag::err_pch_langopt_value_mismatch) <<
"module features";
340 Diags->
Report(diag::err_pch_langopt_value_mismatch)
341 <<
"target Objective-C runtime";
348 Diags->
Report(diag::err_pch_langopt_value_mismatch)
349 <<
"block command names";
357 if (!AllowCompatibleDifferences) {
361 ExistingSanitizers.
clear(ModularSanitizers);
362 ImportedSanitizers.
clear(ModularSanitizers);
363 if (ExistingSanitizers.
Mask != ImportedSanitizers.
Mask) {
364 const std::string Flag =
"-fsanitize=";
366#define SANITIZER(NAME, ID) \
368 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
369 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
370 if (InExistingModule != InImportedModule) \
371 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
372 << InExistingModule << (Flag + NAME); \
374#include "clang/Basic/Sanitizers.def"
392 bool AllowCompatibleDifferences =
true) {
393#define CHECK_TARGET_OPT(Field, Name) \
394 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
396 Diags->Report(diag::err_pch_targetopt_mismatch) \
397 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
408 if (!AllowCompatibleDifferences) {
413#undef CHECK_TARGET_OPT
421 llvm::sort(ExistingFeatures);
422 llvm::sort(ReadFeatures);
428 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
429 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
430 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
431 ExistingFeatures.begin(), ExistingFeatures.end(),
432 std::back_inserter(UnmatchedReadFeatures));
436 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
440 for (StringRef Feature : UnmatchedReadFeatures)
441 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
443 for (StringRef Feature : UnmatchedExistingFeatures)
444 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
448 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
454 bool AllowCompatibleDifferences) {
457 Complain ? &Reader.Diags :
nullptr,
458 AllowCompatibleDifferences);
463 bool AllowCompatibleDifferences) {
466 Complain ? &Reader.Diags :
nullptr,
467 AllowCompatibleDifferences);
472using MacroDefinitionsMap =
473 llvm::StringMap<std::pair<StringRef,
bool >>;
474using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
489 for (
auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
498 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror=" +
517 bool SystemHeaderWarningsInModule,
526 !SystemHeaderWarningsInModule) {
528 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Wsystem-headers";
535 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror";
542 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Weverything -Werror";
549 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-pedantic-errors";
573 assert(!ModuleName.empty() &&
"diagnostic options read before module name");
577 assert(M &&
"missing module");
592 assert(ModuleMgr.
size() >= 1 &&
"what ASTFile is this then");
601 bool SystemHeaderWarningsInModule =
608 SystemHeaderWarningsInModule, Complain);
615 MacroDefinitionsMap &Macros,
617 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
618 StringRef Macro = PPOpts.
Macros[I].first;
619 bool IsUndef = PPOpts.
Macros[I].second;
621 std::pair<StringRef, StringRef> MacroPair = Macro.split(
'=');
622 StringRef MacroName = MacroPair.first;
623 StringRef MacroBody = MacroPair.second;
627 if (MacroNames && !Macros.count(MacroName))
628 MacroNames->push_back(MacroName);
630 Macros[MacroName] = std::make_pair(
"",
true);
635 if (MacroName.size() == Macro.size())
639 StringRef::size_type End = MacroBody.find_first_of(
"\n\r");
640 MacroBody = MacroBody.substr(0, End);
643 if (MacroNames && !Macros.count(MacroName))
644 MacroNames->push_back(MacroName);
645 Macros[MacroName] = std::make_pair(MacroBody,
false);
669 std::string &SuggestedPredefines,
const LangOptions &LangOpts,
673 MacroDefinitionsMap ASTFileMacros;
675 MacroDefinitionsMap ExistingMacros;
678 &ExistingMacroNames);
682 SuggestedPredefines +=
"# 1 \"<command line>\" 1\n";
684 for (
unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
686 StringRef MacroName = ExistingMacroNames[I];
687 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
690 llvm::StringMap<std::pair<StringRef,
bool >>::iterator Known =
691 ASTFileMacros.find(MacroName);
697 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
true;
705 if (Existing.second) {
706 SuggestedPredefines +=
"#undef ";
707 SuggestedPredefines += MacroName.str();
708 SuggestedPredefines +=
'\n';
710 SuggestedPredefines +=
"#define ";
711 SuggestedPredefines += MacroName.str();
712 SuggestedPredefines +=
' ';
713 SuggestedPredefines += Existing.first.str();
714 SuggestedPredefines +=
'\n';
721 if (Existing.second != Known->second.second) {
723 Diags->
Report(diag::err_pch_macro_def_undef)
724 << MacroName << Known->second.second;
731 if (Existing.second || Existing.first == Known->second.first) {
732 ASTFileMacros.erase(Known);
738 Diags->
Report(diag::err_pch_macro_def_conflict)
739 << MacroName << Known->second.first << Existing.first;
745 SuggestedPredefines +=
"# 1 \"<built-in>\" 2\n";
750 for (
const auto &MacroName : ASTFileMacros.keys()) {
752 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
false;
769 if (LangOpts.Modules &&
779 for (
unsigned I = 0, N = ExistingPPOpts.
Includes.size(); I != N; ++I) {
786 SuggestedPredefines +=
"#include \"";
787 SuggestedPredefines +=
File;
788 SuggestedPredefines +=
"\"\n";
798 SuggestedPredefines +=
"#include \"";
799 SuggestedPredefines +=
File;
800 SuggestedPredefines +=
"\"\n";
803 for (
unsigned I = 0, N = ExistingPPOpts.
MacroIncludes.size(); I != N; ++I) {
808 SuggestedPredefines +=
"#__include_macros \"";
809 SuggestedPredefines +=
File;
810 SuggestedPredefines +=
"\"\n##\n";
817 bool ReadMacros,
bool Complain,
818 std::string &SuggestedPredefines) {
822 PPOpts, ExistingPPOpts, ReadMacros, Complain ? &Reader.Diags :
nullptr,
828 std::string &SuggestedPredefines) {
840 StringRef SpecificModuleCachePath,
841 StringRef ExistingModuleCachePath,
846 SpecificModuleCachePath == ExistingModuleCachePath)
849 VFS.equivalent(SpecificModuleCachePath, ExistingModuleCachePath);
850 if (EqualOrErr && *EqualOrErr)
853 Diags->
Report(diag::err_pch_modulecache_mismatch)
854 << SpecificModuleCachePath << ExistingModuleCachePath;
859 StringRef SpecificModuleCachePath,
862 SpecificModuleCachePath,
864 Complain ? &Reader.Diags :
nullptr,
878 const char *Error =
nullptr;
880 uint64_t Val = llvm::decodeULEB128(
P, &Length,
nullptr, &Error);
882 llvm::report_fatal_error(Error);
888static std::pair<unsigned, unsigned>
891 if ((
unsigned)KeyLen != KeyLen)
892 llvm::report_fatal_error(
"key too large");
895 if ((
unsigned)DataLen != DataLen)
896 llvm::report_fatal_error(
"data too large");
898 return std::make_pair(KeyLen, DataLen);
902 bool TakeOwnership) {
903 DeserializationListener = Listener;
904 OwnsDeserializationListener = TakeOwnership;
915 Reader.ReadModuleOffsetMap(MF);
917 unsigned ModuleFileIndex =
ID.getModuleFileIndex();
924 assert(OwningModuleFile);
928 if (!ModuleFileIndex)
944std::pair<unsigned, unsigned>
951 using namespace llvm::support;
954 unsigned N = endian::readNext<uint16_t, llvm::endianness::little>(d);
956 F, endian::readNext<IdentifierID, llvm::endianness::little>(d));
963 Args.push_back(FirstII);
964 for (
unsigned I = 1; I != N; ++I)
965 Args.push_back(Reader.getLocalIdentifier(
966 F, endian::readNext<IdentifierID, llvm::endianness::little>(d)));
974 using namespace llvm::support;
978 Result.ID = Reader.getGlobalSelectorID(
979 F, endian::readNext<uint32_t, llvm::endianness::little>(d));
980 unsigned FullInstanceBits =
981 endian::readNext<uint16_t, llvm::endianness::little>(d);
982 unsigned FullFactoryBits =
983 endian::readNext<uint16_t, llvm::endianness::little>(d);
984 Result.InstanceBits = FullInstanceBits & 0x3;
985 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
986 Result.FactoryBits = FullFactoryBits & 0x3;
987 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
988 unsigned NumInstanceMethods = FullInstanceBits >> 3;
989 unsigned NumFactoryMethods = FullFactoryBits >> 3;
992 for (
unsigned I = 0; I != NumInstanceMethods; ++I) {
996 endian::readNext<DeclID, llvm::endianness::little>(d))))
997 Result.Instance.push_back(Method);
1001 for (
unsigned I = 0; I != NumFactoryMethods; ++I) {
1005 endian::readNext<DeclID, llvm::endianness::little>(d))))
1006 Result.Factory.push_back(Method);
1013 return llvm::djbHash(a);
1016std::pair<unsigned, unsigned>
1023 assert(n >= 2 && d[n-1] ==
'\0');
1024 return StringRef((
const char*) d, n-1);
1030 bool IsInteresting =
1041 bool Value = Bits & 0x1;
1047 using namespace llvm::support;
1050 endian::readNext<IdentifierID, llvm::endianness::little>(d);
1051 return Reader.getGlobalIdentifierID(F, RawID >> 1);
1064 const unsigned char* d,
1066 using namespace llvm::support;
1069 endian::readNext<IdentifierID, llvm::endianness::little>(d);
1070 bool IsInteresting = RawID & 0x01;
1080 II = &Reader.getIdentifierTable().getOwn(k);
1084 Reader.markIdentifierUpToDate(II);
1086 IdentifierID ID = Reader.getGlobalIdentifierID(F, RawID);
1087 if (!IsInteresting) {
1090 Reader.SetIdentifierInfo(ID, II);
1094 unsigned ObjCOrBuiltinID =
1095 endian::readNext<uint16_t, llvm::endianness::little>(d);
1096 unsigned Bits = endian::readNext<uint16_t, llvm::endianness::little>(d);
1097 bool CPlusPlusOperatorKeyword =
readBit(Bits);
1098 bool HasRevertedTokenIDToIdentifier =
readBit(Bits);
1099 bool Poisoned =
readBit(Bits);
1100 bool ExtensionToken =
readBit(Bits);
1101 bool HadMacroDefinition =
readBit(Bits);
1103 assert(Bits == 0 &&
"Extra bits in the identifier?");
1104 DataLen -=
sizeof(uint16_t) * 2;
1108 if (HasRevertedTokenIDToIdentifier && II->
getTokenID() != tok::identifier)
1113 "Incorrect extension token flag");
1114 (void)ExtensionToken;
1118 "Incorrect C++ operator keyword flag");
1119 (void)CPlusPlusOperatorKeyword;
1123 if (HadMacroDefinition) {
1124 uint32_t MacroDirectivesOffset =
1125 endian::readNext<uint32_t, llvm::endianness::little>(d);
1128 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1131 Reader.SetIdentifierInfo(ID, II);
1137 for (; DataLen > 0; DataLen -=
sizeof(
DeclID))
1138 DeclIDs.push_back(Reader.getGlobalDeclID(
1141 endian::readNext<DeclID, llvm::endianness::little>(d))));
1142 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1149 : Kind(Name.getNameKind()) {
1152 Data = (uint64_t)Name.getAsIdentifierInfo();
1157 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1160 Data = Name.getCXXOverloadedOperator();
1163 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1166 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1167 ->getDeclName().getAsIdentifierInfo();
1179 llvm::FoldingSetNodeID ID;
1180 ID.AddInteger(Kind);
1203 return ID.computeStableHash();
1207ASTDeclContextNameLookupTrait::ReadFileRef(
const unsigned char *&d) {
1208 using namespace llvm::support;
1210 uint32_t ModuleFileID =
1211 endian::readNext<uint32_t, llvm::endianness::little>(d);
1212 return Reader.getLocalModuleFile(F, ModuleFileID);
1215std::pair<unsigned, unsigned>
1216ASTDeclContextNameLookupTrait::ReadKeyDataLength(
const unsigned char *&d) {
1221ASTDeclContextNameLookupTrait::ReadKey(
const unsigned char *d,
unsigned) {
1222 using namespace llvm::support;
1230 Data = (uint64_t)Reader.getLocalIdentifier(
1231 F, endian::readNext<IdentifierID, llvm::endianness::little>(d));
1236 Data = (uint64_t)Reader
1238 F, endian::readNext<uint32_t, llvm::endianness::little>(d))
1256 const unsigned char *d,
1259 using namespace llvm::support;
1261 for (
unsigned NumDecls = DataLen /
sizeof(
DeclID); NumDecls; --NumDecls) {
1263 Reader, F, endian::readNext<DeclID, llvm::endianness::little>(d));
1264 Val.
insert(Reader.getGlobalDeclID(F, ID));
1268bool ASTReader::ReadLexicalDeclContextStorage(
ModuleFile &M,
1269 BitstreamCursor &Cursor,
1272 assert(Offset != 0);
1275 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1276 Error(std::move(Err));
1284 Error(MaybeCode.takeError());
1287 unsigned Code = MaybeCode.get();
1290 if (!MaybeRecCode) {
1291 Error(MaybeRecCode.takeError());
1294 unsigned RecCode = MaybeRecCode.get();
1296 Error(
"Expected lexical block");
1300 assert(!isa<TranslationUnitDecl>(DC) &&
1301 "expected a TU_UPDATE_LEXICAL record for TU");
1306 auto &Lex = LexicalDecls[DC];
1308 Lex = std::make_pair(
1311 Blob.size() /
sizeof(
DeclID)));
1317bool ASTReader::ReadVisibleDeclContextStorage(
ModuleFile &M,
1318 BitstreamCursor &Cursor,
1321 assert(Offset != 0);
1324 if (llvm::Error Err =
Cursor.JumpToBit(Offset)) {
1325 Error(std::move(Err));
1333 Error(MaybeCode.takeError());
1336 unsigned Code = MaybeCode.get();
1339 if (!MaybeRecCode) {
1340 Error(MaybeRecCode.takeError());
1343 unsigned RecCode = MaybeRecCode.get();
1345 Error(
"Expected visible lookup table block");
1351 auto *
Data = (
const unsigned char*)Blob.data();
1352 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&M,
Data});
1356void ASTReader::Error(StringRef Msg)
const {
1357 Error(diag::err_fe_pch_malformed, Msg);
1358 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1359 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1360 Diag(diag::note_module_cache_path)
1361 << PP.getHeaderSearchInfo().getModuleCachePath();
1365void ASTReader::Error(
unsigned DiagID, StringRef Arg1, StringRef Arg2,
1366 StringRef Arg3)
const {
1367 if (Diags.isDiagnosticInFlight())
1368 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1370 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1373void ASTReader::Error(llvm::Error &&Err)
const {
1374 llvm::Error RemainingErr =
1376 auto Diag =
E.getDiagnostic().second;
1381 assert(NumArgs <= 3 &&
"Can only have up to 3 arguments");
1382 StringRef Arg1, Arg2, Arg3;
1385 Arg3 =
Diag.getStringArg(2);
1388 Arg2 =
Diag.getStringArg(1);
1391 Arg1 =
Diag.getStringArg(0);
1393 Error(
Diag.getDiagID(), Arg1, Arg2, Arg3);
1409 std::map<int, int> FileIDs;
1411 for (
unsigned I = 0;
Record[Idx]; ++I) {
1419 std::vector<LineEntry> Entries;
1420 while (Idx <
Record.size()) {
1424 unsigned NumEntries =
Record[Idx++];
1425 assert(NumEntries &&
"no line entries for file ID");
1427 Entries.reserve(NumEntries);
1428 for (
unsigned I = 0; I != NumEntries; ++I) {
1429 unsigned FileOffset =
Record[Idx++];
1430 unsigned LineNo =
Record[Idx++];
1431 int FilenameID = FileIDs[
Record[Idx++]];
1434 unsigned IncludeOffset =
Record[Idx++];
1436 FileKind, IncludeOffset));
1443llvm::Error ASTReader::ReadSourceManagerBlock(
ModuleFile &F) {
1444 using namespace SrcMgr;
1452 SLocEntryCursor = F.
Stream;
1455 if (llvm::Error Err = F.
Stream.SkipBlock())
1466 SLocEntryCursor.advanceSkippingSubblocks();
1468 return MaybeE.takeError();
1469 llvm::BitstreamEntry
E = MaybeE.get();
1472 case llvm::BitstreamEntry::SubBlock:
1473 case llvm::BitstreamEntry::Error:
1474 return llvm::createStringError(std::errc::illegal_byte_sequence,
1475 "malformed block record in AST file");
1476 case llvm::BitstreamEntry::EndBlock:
1477 return llvm::Error::success();
1478 case llvm::BitstreamEntry::Record:
1487 SLocEntryCursor.readRecord(
E.ID,
Record, &Blob);
1489 return MaybeRecord.takeError();
1490 switch (MaybeRecord.get()) {
1498 return llvm::Error::success();
1509 return std::move(Err);
1513 return MaybeEntry.takeError();
1515 llvm::BitstreamEntry Entry = MaybeEntry.get();
1516 if (Entry.Kind != llvm::BitstreamEntry::Record)
1517 return llvm::createStringError(
1518 std::errc::illegal_byte_sequence,
1519 "incorrectly-formatted source location entry in AST file");
1525 return MaybeSLOC.takeError();
1527 switch (MaybeSLOC.get()) {
1529 return llvm::createStringError(
1530 std::errc::illegal_byte_sequence,
1531 "incorrectly-formatted source location entry in AST file");
1541 GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - SLocOffset - 1);
1542 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
1543 "Corrupted global sloc offset map");
1548 auto It = llvm::upper_bound(
1551 int ID = F->SLocEntryBaseID + LocalIndex;
1552 std::size_t Index = -ID - 2;
1553 if (!SourceMgr.SLocEntryOffsetLoaded[Index]) {
1554 assert(!SourceMgr.SLocEntryLoaded[Index]);
1555 auto MaybeEntryOffset = readSLocOffset(F, LocalIndex);
1556 if (!MaybeEntryOffset) {
1557 Error(MaybeEntryOffset.takeError());
1561 SourceMgr.LoadedSLocEntryTable[Index] =
1562 SrcMgr::SLocEntry::getOffsetOnly(*MaybeEntryOffset);
1563 SourceMgr.SLocEntryOffsetLoaded[Index] = true;
1565 return Offset < SourceMgr.LoadedSLocEntryTable[Index].getOffset();
1580 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1581 Error(
"source location entry ID out-of-range for AST file");
1587 auto ReadBuffer = [
this](
1588 BitstreamCursor &SLocEntryCursor,
1589 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1594 Error(MaybeCode.takeError());
1597 unsigned Code = MaybeCode.get();
1600 SLocEntryCursor.readRecord(Code,
Record, &Blob);
1601 if (!MaybeRecCode) {
1602 Error(MaybeRecCode.takeError());
1605 unsigned RecCode = MaybeRecCode.get();
1610 const llvm::compression::Format F =
1611 Blob.size() > 0 && Blob.data()[0] == 0x78
1612 ? llvm::compression::Format::Zlib
1613 : llvm::compression::Format::Zstd;
1614 if (
const char *Reason = llvm::compression::getReasonIfUnsupported(F)) {
1619 if (llvm::Error
E = llvm::compression::decompress(
1620 F, llvm::arrayRefFromStringRef(Blob), Decompressed,
Record[0])) {
1621 Error(
"could not decompress embedded file contents: " +
1622 llvm::toString(std::move(
E)));
1625 return llvm::MemoryBuffer::getMemBufferCopy(
1626 llvm::toStringRef(Decompressed), Name);
1628 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name,
true);
1630 Error(
"AST record has invalid code");
1635 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1639 Error(std::move(Err));
1646 ++NumSLocEntriesRead;
1649 Error(MaybeEntry.takeError());
1652 llvm::BitstreamEntry Entry = MaybeEntry.get();
1654 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1655 Error(
"incorrectly-formatted source location entry in AST file");
1662 SLocEntryCursor.readRecord(Entry.ID,
Record, &Blob);
1664 Error(MaybeSLOC.takeError());
1667 switch (MaybeSLOC.get()) {
1669 Error(
"incorrectly-formatted source location entry in AST file");
1675 unsigned InputID =
Record[4];
1676 InputFile IF = getInputFile(*F, InputID);
1689 IncludeLoc = getImportLocation(F);
1693 FileID FID = SourceMgr.createFileID(*
File, IncludeLoc, FileCharacter, ID,
1696 FileInfo.NumCreatedFIDs =
Record[5];
1700 unsigned NumFileDecls =
Record[7];
1701 if (NumFileDecls && ContextObj) {
1703 assert(F->
FileSortedDecls &&
"FILE_SORTED_DECLS not encountered yet ?");
1709 SourceMgr.getOrCreateContentCache(*
File, isSystem(FileCharacter));
1713 auto Buffer = ReadBuffer(SLocEntryCursor,
File->getName());
1716 SourceMgr.overrideFileContents(*
File, std::move(Buffer));
1723 const char *Name = Blob.data();
1724 unsigned Offset =
Record[0];
1729 IncludeLoc = getImportLocation(F);
1732 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1735 FileID FID = SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1736 BaseOffset + Offset, IncludeLoc);
1738 auto &FileInfo = SourceMgr.getSLocEntry(FID).getFile();
1739 FileInfo.setHasLineDirectives();
1749 SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
1763 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1764 Error(
"source location entry ID out-of-range for AST file");
1769 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1787 assert(SourceMgr.getMainFileID().isValid() &&
"missing main file");
1788 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1798 uint64_t *StartOfBlockOffset) {
1799 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID))
1802 if (StartOfBlockOffset)
1803 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1806 uint64_t Offset = Cursor.GetCurrentBitNo();
1809 return MaybeCode.takeError();
1810 unsigned Code = MaybeCode.get();
1813 if (Code != llvm::bitc::DEFINE_ABBREV) {
1814 if (llvm::Error Err = Cursor.JumpToBit(Offset))
1816 return llvm::Error::success();
1818 if (llvm::Error Err = Cursor.ReadAbbrevRecord())
1834 case tok::annot_pragma_loop_hint: {
1837 Info->Option = ReadToken(M,
Record, Idx);
1838 unsigned NumTokens =
Record[Idx++];
1840 Toks.reserve(NumTokens);
1841 for (
unsigned I = 0; I < NumTokens; ++I)
1842 Toks.push_back(ReadToken(M,
Record, Idx));
1843 Info->Toks =
llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
1847 case tok::annot_pragma_pack: {
1850 auto SlotLabel = ReadString(
Record, Idx);
1852 llvm::StringRef(SlotLabel).copy(PP.getPreprocessorAllocator());
1853 Info->Alignment = ReadToken(M,
Record, Idx);
1858 case tok::annot_pragma_openmp:
1859 case tok::annot_pragma_openmp_end:
1860 case tok::annot_pragma_unused:
1861 case tok::annot_pragma_openacc:
1862 case tok::annot_pragma_openacc_end:
1865 llvm_unreachable(
"missing deserialization code for annotation token");
1882 if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1884 consumeError(std::move(Err));
1896 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1898 Stream.advanceSkippingSubblocks(Flags);
1900 Error(MaybeEntry.takeError());
1903 llvm::BitstreamEntry Entry = MaybeEntry.get();
1905 switch (Entry.Kind) {
1906 case llvm::BitstreamEntry::SubBlock:
1907 case llvm::BitstreamEntry::Error:
1908 Error(
"malformed block record in AST file");
1910 case llvm::BitstreamEntry::EndBlock:
1912 case llvm::BitstreamEntry::Record:
1923 Error(MaybeRecType.takeError());
1939 unsigned NextIndex = 1;
1946 PP.getPreprocessorAllocator());
1949 bool isC99VarArgs =
Record[NextIndex++];
1950 bool isGNUVarArgs =
Record[NextIndex++];
1951 bool hasCommaPasting =
Record[NextIndex++];
1952 MacroParams.clear();
1953 unsigned NumArgs =
Record[NextIndex++];
1954 for (
unsigned i = 0; i != NumArgs; ++i)
1955 MacroParams.push_back(getLocalIdentifier(F,
Record[NextIndex++]));
1969 if (NextIndex + 1 ==
Record.size() && PP.getPreprocessingRecord() &&
1973 GlobalID = getGlobalPreprocessedEntityID(F,
Record[NextIndex]);
1975 PreprocessingRecord::PPEntityID PPID =
1976 PPRec.getPPEntityID(GlobalID - 1,
true);
1978 PPRec.getPreprocessedEntity(PPID));
1980 PPRec.RegisterMacroDefinition(Macro, PPDef);
1991 if (MacroTokens.empty()) {
1992 Error(
"unexpected number of macro tokens for a macro in AST file");
1997 MacroTokens[0] = ReadToken(F,
Record, Idx);
1998 MacroTokens = MacroTokens.drop_front();
2007 unsigned LocalID)
const {
2009 ReadModuleOffsetMap(M);
2014 &&
"Invalid index into preprocessed entity index remap");
2016 return LocalID + I->second;
2019const FileEntry *HeaderFileInfoTrait::getFile(
const internal_key_type &Key) {
2021 if (!Key.Imported) {
2027 std::string Resolved = std::string(Key.Filename);
2028 Reader.ResolveImportedPath(M, Resolved);
2035 uint8_t buf[
sizeof(ikey.
Size) +
sizeof(ikey.
ModTime)];
2038 return llvm::xxh3_64bits(buf);
2059 return FEA && FEA == FEB;
2062std::pair<unsigned, unsigned>
2063HeaderFileInfoTrait::ReadKeyDataLength(
const unsigned char*& d) {
2068HeaderFileInfoTrait::ReadKey(
const unsigned char *d,
unsigned) {
2069 using namespace llvm::support;
2072 ikey.
Size = off_t(endian::readNext<uint64_t, llvm::endianness::little>(d));
2074 time_t(endian::readNext<uint64_t, llvm::endianness::little>(d));
2083 using namespace llvm::support;
2085 const unsigned char *End = d + DataLen;
2087 unsigned Flags = *d++;
2089 bool Included = (Flags >> 6) & 0x01;
2094 Reader.getPreprocessor().getIncludedFiles().insert(FE);
2097 HFI.
isImport |= (Flags >> 5) & 0x01;
2099 HFI.
DirInfo = (Flags >> 1) & 0x07;
2102 M, endian::readNext<IdentifierID, llvm::endianness::little>(d));
2103 if (
unsigned FrameworkOffset =
2104 endian::readNext<uint32_t, llvm::endianness::little>(d)) {
2107 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
2108 HFI.
Framework = HS->getUniqueFrameworkName(FrameworkName);
2111 assert((End - d) % 4 == 0 &&
2112 "Wrong data length in HeaderFileInfo deserialization");
2114 uint32_t LocalSMID =
2115 endian::readNext<uint32_t, llvm::endianness::little>(d);
2121 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
2122 Module *Mod = Reader.getSubmodule(GlobalSMID);
2125 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
2129 Reader.ResolveImportedPath(M,
Filename);
2133 ModMap.
addHeader(Mod, H, HeaderRole,
true);
2145 uint32_t MacroDirectivesOffset) {
2146 assert(NumCurrentElementsDeserializing > 0 &&
"Missing deserialization guard");
2147 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
2154 for (
ModuleFile &I : llvm::reverse(ModuleMgr)) {
2155 BitstreamCursor &MacroCursor = I.MacroCursor;
2158 if (MacroCursor.getBitcodeBytes().empty())
2161 BitstreamCursor Cursor = MacroCursor;
2162 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
2163 Error(std::move(Err));
2171 Error(MaybeE.takeError());
2174 llvm::BitstreamEntry
E = MaybeE.get();
2177 case llvm::BitstreamEntry::SubBlock:
2178 case llvm::BitstreamEntry::Error:
2179 Error(
"malformed block record in AST file");
2181 case llvm::BitstreamEntry::EndBlock:
2184 case llvm::BitstreamEntry::Record: {
2188 Error(MaybeRecord.takeError());
2191 switch (MaybeRecord.get()) {
2199 updateOutOfDateIdentifier(*II);
2218 class IdentifierLookupVisitor {
2221 unsigned PriorGeneration;
2222 unsigned &NumIdentifierLookups;
2223 unsigned &NumIdentifierLookupHits;
2227 IdentifierLookupVisitor(StringRef Name,
unsigned PriorGeneration,
2228 unsigned &NumIdentifierLookups,
2229 unsigned &NumIdentifierLookupHits)
2231 PriorGeneration(PriorGeneration),
2232 NumIdentifierLookups(NumIdentifierLookups),
2233 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2247 ++NumIdentifierLookups;
2248 ASTIdentifierLookupTable::iterator Pos =
2249 IdTable->find_hashed(Name, NameHash, &Trait);
2250 if (Pos == IdTable->end())
2256 ++NumIdentifierLookupHits;
2272 unsigned PriorGeneration = 0;
2273 if (getContext().getLangOpts().Modules)
2274 PriorGeneration = IdentifierGeneration[&II];
2280 if (!loadGlobalIndex()) {
2281 if (GlobalIndex->lookupIdentifier(II.
getName(), Hits)) {
2286 IdentifierLookupVisitor Visitor(II.
getName(), PriorGeneration,
2287 NumIdentifierLookups,
2288 NumIdentifierLookupHits);
2289 ModuleMgr.visit(Visitor, HitsPtr);
2290 markIdentifierUpToDate(&II);
2300 if (getContext().getLangOpts().Modules)
2301 IdentifierGeneration[II] = getGeneration();
2305 const PendingMacroInfo &PMInfo) {
2310 if (llvm::Error Err =
2312 Error(std::move(Err));
2316 struct ModuleMacroRecord {
2329 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2331 Error(MaybeEntry.takeError());
2334 llvm::BitstreamEntry Entry = MaybeEntry.get();
2336 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2337 Error(
"malformed block record in AST file");
2344 Error(MaybePP.takeError());
2352 ModuleMacros.push_back(ModuleMacroRecord());
2353 auto &Info = ModuleMacros.back();
2354 Info.SubModID = getGlobalSubmoduleID(M,
Record[0]);
2355 Info.MI = getMacro(getGlobalMacroID(M,
Record[1]));
2356 for (
int I = 2, N =
Record.size(); I != N; ++I)
2357 Info.Overrides.push_back(getGlobalSubmoduleID(M,
Record[I]));
2362 Error(
"malformed block record in AST file");
2373 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2375 for (
auto &MMR : ModuleMacros) {
2377 for (
unsigned ModID : MMR.Overrides) {
2378 Module *Mod = getSubmodule(ModID);
2379 auto *Macro = PP.getModuleMacro(Mod, II);
2380 assert(Macro &&
"missing definition for overridden macro");
2381 Overrides.push_back(Macro);
2384 bool Inserted =
false;
2385 Module *Owner = getSubmodule(MMR.SubModID);
2386 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2397 unsigned Idx = 0, N =
Record.size();
2405 MD = PP.AllocateDefMacroDirective(MI,
Loc);
2409 MD = PP.AllocateUndefMacroDirective(
Loc);
2412 bool isPublic =
Record[Idx++];
2413 MD = PP.AllocateVisibilityMacroDirective(
Loc, isPublic);
2425 PP.setLoadedMacroDirective(II, Earliest, Latest);
2428bool ASTReader::shouldDisableValidationForFile(
2466 consumeError(std::move(Err));
2472 consumeError(MaybeCode.takeError());
2474 unsigned Code = MaybeCode.get();
2480 "invalid record type for input file");
2483 consumeError(Maybe.takeError());
2486 assert(
Record[0] == ID &&
"Bogus stored ID or offset");
2495 uint16_t AsRequestedLength =
Record[7];
2497 std::string NameAsRequested = Blob.substr(0, AsRequestedLength).str();
2498 std::string Name = Blob.substr(AsRequestedLength).str();
2500 ResolveImportedPath(F, NameAsRequested);
2501 ResolveImportedPath(F, Name);
2504 Name = NameAsRequested;
2506 return std::make_pair(std::move(NameAsRequested), std::move(Name));
2511 consumeError(MaybeEntry.takeError());
2512 llvm::BitstreamEntry Entry = MaybeEntry.get();
2513 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2514 "expected record type for input file hash");
2519 "invalid record type for input file hash");
2522 consumeError(Maybe.takeError());
2551 consumeError(std::move(Err));
2566 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2579 if ((Overridden || Transient || SkipChecks) && !
File)
2584 std::string ErrorStr =
"could not find file '";
2586 ErrorStr +=
"' referenced by AST file '";
2602 if ((!Overridden && !Transient) && !SkipChecks &&
2603 SM.isFileOverridden(*
File)) {
2617 enum ModificationKind {
2623 std::optional<int64_t> Old = std::nullopt;
2624 std::optional<int64_t> New = std::nullopt;
2626 auto HasInputContentChanged = [&](Change OriginalChange) {
2627 assert(ValidateASTInputFilesContent &&
2628 "We should only check the content of the inputs with "
2629 "ValidateASTInputFilesContent enabled.");
2631 if (StoredContentHash == 0)
2632 return OriginalChange;
2635 if (!MemBuffOrError) {
2637 return OriginalChange;
2638 std::string ErrorStr =
"could not get buffer for file '";
2639 ErrorStr +=
File->getName();
2642 return OriginalChange;
2645 auto ContentHash = xxh3_64bits(MemBuffOrError.get()->getBuffer());
2646 if (StoredContentHash ==
static_cast<uint64_t>(ContentHash))
2647 return Change{Change::None};
2649 return Change{Change::Content};
2651 auto HasInputFileChanged = [&]() {
2652 if (StoredSize !=
File->getSize())
2653 return Change{Change::Size, StoredSize,
File->getSize()};
2654 if (!shouldDisableValidationForFile(F) && StoredTime &&
2655 StoredTime !=
File->getModificationTime()) {
2656 Change MTimeChange = {Change::ModTime, StoredTime,
2657 File->getModificationTime()};
2661 if (ValidateASTInputFilesContent)
2662 return HasInputContentChanged(MTimeChange);
2666 return Change{Change::None};
2669 bool IsOutOfDate =
false;
2670 auto FileChange = SkipChecks ? Change{Change::None} : HasInputFileChanged();
2676 FileChange = HasInputContentChanged(FileChange);
2682 if (!StoredTime && ValidateASTInputFilesContent &&
2683 FileChange.Kind == Change::None)
2684 FileChange = HasInputContentChanged(FileChange);
2687 if (!Overridden && FileChange.Kind != Change::None) {
2688 if (Complain && !Diags.isDiagnosticInFlight()) {
2691 while (!ImportStack.back()->ImportedBy.empty())
2692 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2695 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2696 Diag(diag::err_fe_ast_file_modified)
2698 << TopLevelPCHName << FileChange.Kind
2699 << (FileChange.Old && FileChange.New)
2700 << llvm::itostr(FileChange.Old.value_or(0))
2701 << llvm::itostr(FileChange.New.value_or(0));
2704 if (ImportStack.size() > 1) {
2705 Diag(diag::note_pch_required_by)
2706 <<
Filename << ImportStack[0]->FileName;
2707 for (
unsigned I = 1; I < ImportStack.size(); ++I)
2708 Diag(diag::note_pch_required_by)
2709 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2712 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2742 llvm::sys::path::append(Buffer, Prefix,
Filename);
2743 Filename.assign(Buffer.begin(), Buffer.end());
2758 llvm_unreachable(
"unknown ASTReadResult");
2762 BitstreamCursor &Stream,
unsigned ClientLoadCapabilities,
2764 std::string &SuggestedPredefines) {
2767 consumeError(std::move(Err));
2778 consumeError(MaybeEntry.takeError());
2781 llvm::BitstreamEntry Entry = MaybeEntry.get();
2783 switch (Entry.Kind) {
2784 case llvm::BitstreamEntry::Error:
2785 case llvm::BitstreamEntry::SubBlock:
2788 case llvm::BitstreamEntry::EndBlock:
2791 case llvm::BitstreamEntry::Record:
2799 if (!MaybeRecordType) {
2801 consumeError(MaybeRecordType.takeError());
2806 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2807 if (ParseLanguageOptions(
Record, Complain, Listener,
2808 AllowCompatibleConfigurationMismatch))
2809 Result = ConfigurationMismatch;
2814 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2815 if (ParseTargetOptions(
Record, Complain, Listener,
2816 AllowCompatibleConfigurationMismatch))
2817 Result = ConfigurationMismatch;
2822 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2823 if (!AllowCompatibleConfigurationMismatch &&
2824 ParseFileSystemOptions(
Record, Complain, Listener))
2825 Result = ConfigurationMismatch;
2830 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2831 if (!AllowCompatibleConfigurationMismatch &&
2832 ParseHeaderSearchOptions(
Record, Complain, Listener))
2833 Result = ConfigurationMismatch;
2838 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2839 if (!AllowCompatibleConfigurationMismatch &&
2840 ParsePreprocessorOptions(
Record, Complain, Listener,
2841 SuggestedPredefines))
2842 Result = ConfigurationMismatch;
2852 unsigned ClientLoadCapabilities) {
2853 BitstreamCursor &Stream = F.
Stream;
2856 Error(std::move(Err));
2866 bool HasReadUnhashedControlBlock =
false;
2867 auto readUnhashedControlBlockOnce = [&]() {
2868 if (!HasReadUnhashedControlBlock) {
2869 HasReadUnhashedControlBlock =
true;
2870 if (ASTReadResult
Result =
2871 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2877 bool DisableValidation = shouldDisableValidationForFile(F);
2881 unsigned NumInputs = 0;
2882 unsigned NumUserInputs = 0;
2883 StringRef BaseDirectoryAsWritten;
2887 Error(MaybeEntry.takeError());
2890 llvm::BitstreamEntry Entry = MaybeEntry.get();
2892 switch (Entry.Kind) {
2893 case llvm::BitstreamEntry::Error:
2894 Error(
"malformed block record in AST file");
2896 case llvm::BitstreamEntry::EndBlock: {
2899 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2904 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2911 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2917 unsigned N = ValidateSystemInputs ? NumInputs : NumUserInputs;
2923 for (
unsigned I = 0; I < N; ++I) {
2924 InputFile IF = getInputFile(F, I+1, Complain);
2936 for (
unsigned I = 0; I < N; ++I) {
2937 bool IsSystem = I >= NumUserInputs;
2948 case llvm::BitstreamEntry::SubBlock:
2952 if (llvm::Error Err = Stream.SkipBlock()) {
2953 Error(std::move(Err));
2957 Error(
"malformed block record in AST file");
2967 if (Listener && !ImportedBy) {
2973 bool AllowCompatibleConfigurationMismatch =
2977 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2978 AllowCompatibleConfigurationMismatch, *Listener,
2979 SuggestedPredefines);
2981 Error(
"malformed block record in AST file");
2985 if (DisableValidation ||
2986 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
2994 }
else if (llvm::Error Err = Stream.SkipBlock()) {
2995 Error(std::move(Err));
3001 if (llvm::Error Err = Stream.SkipBlock()) {
3002 Error(std::move(Err));
3008 case llvm::BitstreamEntry::Record:
3017 Stream.readRecord(Entry.ID,
Record, &Blob);
3018 if (!MaybeRecordType) {
3019 Error(MaybeRecordType.takeError());
3025 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3027 : diag::err_pch_version_too_new);
3031 bool hasErrors =
Record[7];
3032 if (hasErrors && !DisableValidation) {
3035 if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
3036 canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
3039 if (!AllowASTWithCompilerErrors) {
3040 Diag(diag::err_pch_with_compiler_errors);
3045 Diags.ErrorOccurred =
true;
3046 Diags.UncompilableErrorOccurred =
true;
3047 Diags.UnrecoverableErrorOccurred =
true;
3060 StringRef ASTBranch = Blob;
3061 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
3062 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3063 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
3073 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3077 unsigned Idx = 0, N =
Record.size();
3082 bool IsImportingStdCXXModule =
Record[Idx++];
3086 auto [ImportLoc, ImportModuleFileIndex] =
3087 ReadUntranslatedSourceLocation(
Record[Idx++]);
3089 assert(ImportModuleFileIndex == 0);
3090 off_t StoredSize = !IsImportingStdCXXModule ? (off_t)
Record[Idx++] : 0;
3091 time_t StoredModTime =
3092 !IsImportingStdCXXModule ? (time_t)
Record[Idx++] : 0;
3095 if (!IsImportingStdCXXModule) {
3096 auto FirstSignatureByte =
Record.begin() + Idx;
3102 std::string ImportedName = ReadString(
Record, Idx);
3103 std::string ImportedFile;
3112 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
3113 ImportedName, !IsImportingStdCXXModule);
3117 if (!IsImportingStdCXXModule) {
3118 if (ImportedFile.empty()) {
3121 ImportedFile = ReadPath(BaseDirectoryAsWritten,
Record, Idx);
3124 }
else if (ImportedFile.empty()) {
3125 Diag(clang::diag::err_failed_to_find_module_file) << ImportedName;
3131 unsigned Capabilities = ClientLoadCapabilities;
3132 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3133 Capabilities &= ~ARR_Missing;
3136 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
3137 Loaded, StoredSize, StoredModTime,
3138 StoredSignature, Capabilities);
3141 bool recompilingFinalized =
3142 Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
3143 getModuleManager().getModuleCache().isPCMFinal(F.
FileName);
3145 Diag(diag::note_module_file_imported_by)
3147 if (recompilingFinalized)
3148 Diag(diag::note_module_file_conflict);
3151 case Failure:
return Failure;
3154 case OutOfDate:
return OutOfDate;
3156 case ConfigurationMismatch:
return ConfigurationMismatch;
3157 case HadErrors:
return HadErrors;
3177 Diag(diag::remark_module_import)
3179 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
3185 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3193 BaseDirectoryAsWritten = Blob;
3195 "MODULE_DIRECTORY found before MODULE_NAME");
3197 if (!PP.getPreprocessorOpts().ModulesCheckRelocated)
3201 Module *M = PP.getHeaderSearchInfo().lookupModule(
3208 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
3211 auto BuildDir = PP.getFileManager().getOptionalDirectoryRef(Blob);
3212 if (!BuildDir || *BuildDir != M->
Directory) {
3213 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
3214 Diag(diag::err_imported_module_relocated)
3225 if (ASTReadResult
Result =
3226 ReadModuleMapFileBlock(
Record, F, ImportedBy, ClientLoadCapabilities))
3232 NumUserInputs =
Record[1];
3234 (
const llvm::support::unaligned_uint64_t *)Blob.data();
3243llvm::Error ASTReader::ReadASTBlock(
ModuleFile &F,
3244 unsigned ClientLoadCapabilities) {
3245 BitstreamCursor &Stream = F.
Stream;
3247 if (llvm::Error Err = Stream.EnterSubBlock(
AST_BLOCK_ID))
3256 return MaybeEntry.takeError();
3257 llvm::BitstreamEntry Entry = MaybeEntry.get();
3259 switch (Entry.Kind) {
3260 case llvm::BitstreamEntry::Error:
3261 return llvm::createStringError(
3262 std::errc::illegal_byte_sequence,
3263 "error at end of module block in AST file");
3264 case llvm::BitstreamEntry::EndBlock:
3276 return llvm::Error::success();
3277 case llvm::BitstreamEntry::SubBlock:
3285 if (llvm::Error Err = Stream.SkipBlock())
3287 if (llvm::Error Err = ReadBlockAbbrevs(
3294 if (!PP.getExternalSource())
3295 PP.setExternalSource(
this);
3297 if (llvm::Error Err = Stream.SkipBlock())
3299 if (llvm::Error Err =
3308 if (llvm::Error Err = Stream.SkipBlock()) {
3317 if (!PP.getPreprocessingRecord())
3318 PP.createPreprocessingRecord();
3319 if (!PP.getPreprocessingRecord()->getExternalSource())
3320 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3324 if (llvm::Error Err = ReadSourceManagerBlock(F))
3329 if (llvm::Error Err = ReadSubmoduleBlock(F, ClientLoadCapabilities))
3334 BitstreamCursor
C = Stream;
3336 if (llvm::Error Err = Stream.SkipBlock())
3340 CommentsCursors.push_back(std::make_pair(
C, &F));
3345 if (llvm::Error Err = Stream.SkipBlock())
3351 case llvm::BitstreamEntry::Record:
3360 Stream.readRecord(Entry.ID,
Record, &Blob);
3361 if (!MaybeRecordType)
3362 return MaybeRecordType.takeError();
3394 return llvm::createStringError(
3395 std::errc::illegal_byte_sequence,
3396 "duplicate TYPE_OFFSET record in AST file");
3409 return llvm::createStringError(
3410 std::errc::illegal_byte_sequence,
3411 "duplicate DECL_OFFSET record in AST file");
3423 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3424 LexicalContents Contents(
3426 static_cast<unsigned int>(Blob.size() /
sizeof(
DeclID)));
3427 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3435 auto *
Data = (
const unsigned char*)Blob.data();
3436 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&F,
Data});
3439 if (
Decl *
D = GetExistingDecl(ID))
3440 PendingUpdateRecords.push_back(
3441 PendingUpdateRecord(ID,
D,
false));
3447 reinterpret_cast<const unsigned char *
>(Blob.data());
3455 PP.getIdentifierTable().setExternalIdentifierLookup(
this);
3461 return llvm::createStringError(
3462 std::errc::illegal_byte_sequence,
3463 "duplicate IDENTIFIER_OFFSET record in AST file");
3469 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3481 for (
unsigned I = 0, N =
Record.size(); I != N; )
3482 EagerlyDeserializedDecls.push_back(ReadDeclID(F,
Record, I));
3489 getContext().getLangOpts().BuildingPCHWithObjectFile)
3490 for (
unsigned I = 0, N =
Record.size(); I != N; )
3491 EagerlyDeserializedDecls.push_back(ReadDeclID(F,
Record, I));
3495 if (SpecialTypes.empty()) {
3496 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3497 SpecialTypes.push_back(getGlobalTypeID(F,
Record[I]));
3501 if (SpecialTypes.size() !=
Record.size())
3502 return llvm::createStringError(std::errc::illegal_byte_sequence,
3503 "invalid special-types record");
3505 for (
unsigned I = 0, N =
Record.size(); I != N; ++I) {
3507 if (!SpecialTypes[I])
3508 SpecialTypes[I] =
ID;
3515 TotalNumStatements +=
Record[0];
3516 TotalNumMacros +=
Record[1];
3517 TotalLexicalDeclContexts +=
Record[2];
3518 TotalVisibleDeclContexts +=
Record[3];
3522 for (
unsigned I = 0, N =
Record.size(); I != N; )
3523 UnusedFileScopedDecls.push_back(ReadDeclID(F,
Record, I));
3527 for (
unsigned I = 0, N =
Record.size(); I != N; )
3528 DelegatingCtorDecls.push_back(ReadDeclID(F,
Record, I));
3532 if (
Record.size() % 3 != 0)
3533 return llvm::createStringError(std::errc::illegal_byte_sequence,
3534 "invalid weak identifiers record");
3538 WeakUndeclaredIdentifiers.clear();
3541 for (
unsigned I = 0, N =
Record.size(); I < N; ) {
3542 WeakUndeclaredIdentifiers.push_back(
3543 getGlobalIdentifierID(F,
Record[I++]));
3544 WeakUndeclaredIdentifiers.push_back(
3545 getGlobalIdentifierID(F,
Record[I++]));
3546 WeakUndeclaredIdentifiers.push_back(
3547 ReadSourceLocation(F,
Record, I).getRawEncoding());
3554 unsigned LocalBaseSelectorID =
Record[1];
3560 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3565 std::make_pair(LocalBaseSelectorID,
3577 = ASTSelectorLookupTable::Create(
3581 TotalNumMethodPoolEntries +=
Record[1];
3586 for (
unsigned Idx = 0, N =
Record.size() - 1; Idx < N; ) {
3587 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3589 ReferencedSelectorsData.push_back(ReadSourceLocation(F,
Record, Idx).
3598 PP.setPreambleRecordedPragmaAssumeNonNullLoc(
3599 ReadSourceLocation(F,
Record, Idx));
3607 while (Idx <
Record.size())
3608 SrcLocs.push_back(ReadSourceLocation(F,
Record, Idx));
3609 PP.setDeserializedSafeBufferOptOutMap(SrcLocs);
3616 unsigned Idx = 0, End =
Record.size() - 1;
3617 bool ReachedEOFWhileSkipping =
Record[Idx++];
3618 std::optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3619 if (ReachedEOFWhileSkipping) {
3622 bool FoundNonSkipPortion =
Record[Idx++];
3623 bool FoundElse =
Record[Idx++];
3625 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3626 FoundElse, ElseLoc);
3630 auto Loc = ReadSourceLocation(F,
Record, Idx);
3631 bool WasSkipping =
Record[Idx++];
3632 bool FoundNonSkip =
Record[Idx++];
3633 bool FoundElse =
Record[Idx++];
3634 ConditionalStack.push_back(
3635 {
Loc, WasSkipping, FoundNonSkip, FoundElse});
3637 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3642 if (!
Record.empty() && Listener)
3660 if (!Diags.isDiagnosticInFlight()) {
3662 SourceMgr.noteSLocAddressSpaceUsage(Diags);
3664 return llvm::createStringError(std::errc::invalid_argument,
3665 "ran out of source locations");
3670 unsigned RangeStart =
3672 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3677 GlobalSLocOffsetMap.insert(
3679 - SLocSpaceSize,&F));
3690 ParseLineTable(F,
Record);
3694 for (
unsigned I = 0, N =
Record.size(); I != N; )
3695 ExtVectorDecls.push_back(ReadDeclID(F,
Record, I));
3699 if (
Record.size() % 3 != 0)
3700 return llvm::createStringError(std::errc::illegal_byte_sequence,
3701 "Invalid VTABLE_USES record");
3708 for (
unsigned Idx = 0, N =
Record.size(); Idx != N; ) {
3709 VTableUses.push_back(
3710 {ReadDeclID(F,
Record, Idx),
3711 ReadSourceLocation(F,
Record, Idx).getRawEncoding(),
3718 if (
Record.size() % 2 != 0)
3719 return llvm::createStringError(
3720 std::errc::illegal_byte_sequence,
3721 "Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3723 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3724 PendingInstantiations.push_back(
3725 {ReadDeclID(F,
Record, I),
3726 ReadSourceLocation(F,
Record, I).getRawEncoding()});
3732 return llvm::createStringError(std::errc::illegal_byte_sequence,
3733 "Invalid SEMA_DECL_REFS block");
3734 for (
unsigned I = 0, N =
Record.size(); I != N; )
3735 SemaDeclRefs.push_back(ReadDeclID(F,
Record, I));
3743 unsigned LocalBasePreprocessedEntityID =
Record[0];
3745 unsigned StartingID;
3746 if (!PP.getPreprocessingRecord())
3747 PP.createPreprocessingRecord();
3748 if (!PP.getPreprocessingRecord()->getExternalSource())
3749 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3751 = PP.getPreprocessingRecord()
3758 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3763 std::make_pair(LocalBasePreprocessedEntityID,
3775 if (!PP.getPreprocessingRecord())
3776 PP.createPreprocessingRecord();
3777 if (!PP.getPreprocessingRecord()->getExternalSource())
3778 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3783 GlobalSkippedRangeMap.insert(
3789 if (
Record.size() % 2 != 0)
3790 return llvm::createStringError(
3791 std::errc::illegal_byte_sequence,
3792 "invalid DECL_UPDATE_OFFSETS block in AST file");
3793 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3795 DeclUpdateOffsets[
ID].push_back(std::make_pair(&F,
Record[I++]));
3799 if (
Decl *
D = GetExistingDecl(ID))
3800 PendingUpdateRecords.push_back(
3801 PendingUpdateRecord(ID,
D,
false));
3806 if (
Record.size() % 3 != 0)
3807 return llvm::createStringError(
3808 std::errc::illegal_byte_sequence,
3809 "invalid DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD block in AST "
3811 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3815 assert(BaseOffset &&
"Invalid DeclsBlockStartOffset for module file!");
3818 LocalLexicalOffset ? BaseOffset + LocalLexicalOffset : 0;
3821 LocalVisibleOffset ? BaseOffset + LocalVisibleOffset : 0;
3823 DelayedNamespaceOffsetMap[
ID] = {LexicalOffset, VisibleOffset};
3825 assert(!GetExistingDecl(ID) &&
3826 "We shouldn't load the namespace in the front of delayed "
3827 "namespace lexical and visible block");
3834 return llvm::createStringError(
3835 std::errc::illegal_byte_sequence,
3836 "duplicate OBJC_CATEGORIES_MAP record in AST file");
3849 CUDASpecialDeclRefs.clear();
3850 for (
unsigned I = 0, N =
Record.size(); I != N; )
3851 CUDASpecialDeclRefs.push_back(ReadDeclID(F,
Record, I));
3859 = HeaderFileInfoLookupTable::Create(
3863 &PP.getHeaderSearchInfo(),
3864 Blob.data() +
Record[2]));
3866 PP.getHeaderSearchInfo().SetExternalSource(
this);
3867 if (!PP.getHeaderSearchInfo().getExternalLookup())
3868 PP.getHeaderSearchInfo().SetExternalLookup(
this);
3874 FPPragmaOptions.swap(
Record);
3878 for (
unsigned I = 0,
E =
Record.size(); I !=
E; ) {
3879 auto Name = ReadString(
Record, I);
3880 auto &OptInfo = OpenCLExtensions.OptMap[Name];
3881 OptInfo.Supported =
Record[I++] != 0;
3882 OptInfo.Enabled =
Record[I++] != 0;
3883 OptInfo.WithPragma =
Record[I++] != 0;
3884 OptInfo.Avail =
Record[I++];
3885 OptInfo.Core =
Record[I++];
3886 OptInfo.Opt =
Record[I++];
3891 for (
unsigned I = 0, N =
Record.size(); I != N; )
3892 TentativeDefinitions.push_back(ReadDeclID(F,
Record, I));
3896 for (
unsigned I = 0, N =
Record.size(); I != N; )
3897 KnownNamespaces.push_back(ReadDeclID(F,
Record, I));
3901 if (
Record.size() % 2 != 0)
3902 return llvm::createStringError(std::errc::illegal_byte_sequence,
3903 "invalid undefined-but-used record");
3904 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3905 UndefinedButUsed.push_back(
3906 {ReadDeclID(F,
Record, I),
3907 ReadSourceLocation(F,
Record, I).getRawEncoding()});
3912 for (
unsigned I = 0, N =
Record.size(); I != N;) {
3913 DelayedDeleteExprs.push_back(ReadDeclID(F,
Record, I).getRawValue());
3915 DelayedDeleteExprs.push_back(Count);
3916 for (uint64_t
C = 0;
C < Count; ++
C) {
3917 DelayedDeleteExprs.push_back(ReadSourceLocation(F,
Record, I).getRawEncoding());
3918 bool IsArrayForm =
Record[I++] == 1;
3919 DelayedDeleteExprs.push_back(IsArrayForm);
3929 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3930 unsigned GlobalID = getGlobalSubmoduleID(F,
Record[I++]);
3933 PendingImportedModules.push_back(ImportedSubmodule(GlobalID,
Loc));
3934 if (DeserializationListener)
3935 DeserializationListener->ModuleImportRead(GlobalID,
Loc);
3943 return llvm::createStringError(
3944 std::errc::illegal_byte_sequence,
3945 "duplicate MACRO_OFFSET record in AST file");
3948 unsigned LocalBaseMacroID =
Record[1];
3954 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3958 std::make_pair(LocalBaseMacroID,
3967 LateParsedTemplates.emplace_back(
3968 std::piecewise_construct, std::forward_as_tuple(&F),
3974 return llvm::createStringError(std::errc::illegal_byte_sequence,
3975 "invalid pragma optimize record");
3976 OptimizeOffPragmaLocation = ReadSourceLocation(F,
Record[0]);
3981 return llvm::createStringError(std::errc::illegal_byte_sequence,
3982 "invalid pragma ms_struct record");
3983 PragmaMSStructState =
Record[0];
3988 return llvm::createStringError(
3989 std::errc::illegal_byte_sequence,
3990 "invalid pragma pointers to members record");
3991 PragmaMSPointersToMembersState =
Record[0];
3992 PointersToMembersPragmaLocation = ReadSourceLocation(F,
Record[1]);
3996 for (
unsigned I = 0, N =
Record.size(); I != N; )
3997 UnusedLocalTypedefNameCandidates.push_back(ReadDeclID(F,
Record, I));
4002 return llvm::createStringError(std::errc::illegal_byte_sequence,
4003 "invalid cuda pragma options record");
4004 ForceHostDeviceDepth =
Record[0];
4009 return llvm::createStringError(std::errc::illegal_byte_sequence,
4010 "invalid pragma pack record");
4011 PragmaAlignPackCurrentValue = ReadAlignPackInfo(
Record[0]);
4012 PragmaAlignPackCurrentLocation = ReadSourceLocation(F,
Record[1]);
4013 unsigned NumStackEntries =
Record[2];
4016 PragmaAlignPackStack.clear();
4017 for (
unsigned I = 0; I < NumStackEntries; ++I) {
4018 PragmaAlignPackStackEntry Entry;
4019 Entry.Value = ReadAlignPackInfo(
Record[Idx++]);
4020 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
4021 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
4022 PragmaAlignPackStrings.push_back(ReadString(
Record, Idx));
4023 Entry.SlotLabel = PragmaAlignPackStrings.back();
4024 PragmaAlignPackStack.push_back(Entry);
4031 return llvm::createStringError(std::errc::illegal_byte_sequence,
4032 "invalid pragma float control record");
4034 FpPragmaCurrentLocation = ReadSourceLocation(F,
Record[1]);
4035 unsigned NumStackEntries =
Record[2];
4038 FpPragmaStack.clear();
4039 for (
unsigned I = 0; I < NumStackEntries; ++I) {
4040 FpPragmaStackEntry Entry;
4042 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
4043 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
4044 FpPragmaStrings.push_back(ReadString(
Record, Idx));
4045 Entry.SlotLabel = FpPragmaStrings.back();
4046 FpPragmaStack.push_back(Entry);
4052 for (
unsigned I = 0, N =
Record.size(); I != N; )
4053 DeclsToCheckForDeferredDiags.insert(ReadDeclID(F,
Record, I));
4059void ASTReader::ReadModuleOffsetMap(
ModuleFile &F)
const {
4074 assert(ImportedModuleVector.empty());
4076 while (
Data < DataEnd) {
4080 using namespace llvm::support;
4082 endian::readNext<uint8_t, llvm::endianness::little>(
Data));
4083 uint16_t Len = endian::readNext<uint16_t, llvm::endianness::little>(
Data);
4084 StringRef Name = StringRef((
const char*)
Data, Len);
4088 ? ModuleMgr.lookupByModuleName(Name)
4089 : ModuleMgr.lookupByFileName(Name));
4091 std::string Msg =
"refers to unknown module, cannot find ";
4092 Msg.append(std::string(Name));
4097 ImportedModuleVector.push_back(OM);
4099 uint32_t MacroIDOffset =
4100 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4101 uint32_t PreprocessedEntityIDOffset =
4102 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4103 uint32_t SubmoduleIDOffset =
4104 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4105 uint32_t SelectorIDOffset =
4106 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4108 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
4109 RemapBuilder &Remap) {
4110 constexpr uint32_t
None = std::numeric_limits<uint32_t>::max();
4112 Remap.insert(std::make_pair(Offset,
4113 static_cast<int>(BaseOffset - Offset)));
4116 mapOffset(MacroIDOffset, OM->
BaseMacroID, MacroRemap);
4118 PreprocessedEntityRemap);
4127 unsigned ClientLoadCapabilities) {
4136 "MODULE_NAME should come before MODULE_MAP_FILE");
4137 if (PP.getPreprocessorOpts().ModulesCheckRelocated &&
4143 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
4145 M ? Map.getModuleMapFileForUniquing(M) : std::nullopt;
4147 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
4150 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities)) {
4151 if (
auto ASTFE = M ? M->
getASTFile() : std::nullopt) {
4154 << ASTFE->getName();
4157 Diag(diag::err_imported_module_not_found)
4165 Diag(diag::note_imported_by_pch_module_not_found)
4172 assert(M && M->
Name == F.
ModuleName &&
"found module with different name");
4176 if (!StoredModMap || *StoredModMap != ModMap) {
4177 assert(ModMap &&
"found module is missing module map file");
4179 "top-level import should be verified");
4181 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4182 Diag(diag::err_imported_module_modmap_changed)
4189 for (
unsigned I = 0, N =
Record[Idx++]; I < N; ++I) {
4194 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4195 Error(
"could not find file '" +
Filename +
"' referenced by AST file");
4198 AdditionalStoredMaps.insert(*SF);
4203 if (
auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
4207 if (!AdditionalStoredMaps.erase(ModMap)) {
4208 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4209 Diag(diag::err_module_different_modmap)
4219 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4220 Diag(diag::err_module_different_modmap)
4241 : Known->second.second;
4243 for (
ObjCMethodList *List = &Start; List; List = List->getNext()) {
4245 if (List->getMethod() == Method) {
4253 if (List->getNext())
4254 List->setMethod(List->getNext()->getMethod());
4256 List->setMethod(Method);
4262 for (
Decl *
D : Names) {
4266 if (wasHidden && SemaObj) {
4279 Stack.push_back(Mod);
4280 while (!Stack.empty()) {
4281 Mod = Stack.pop_back_val();
4283 if (NameVisibility <= Mod->NameVisibility) {
4299 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4300 if (Hidden != HiddenNamesMap.end()) {
4302 HiddenNamesMap.erase(Hidden);
4304 assert(!HiddenNamesMap.contains(Mod) &&
4305 "making names visible added hidden names");
4312 I = Exports.begin(),
E = Exports.end(); I !=
E; ++I) {
4314 if (
Visited.insert(Exported).second)
4315 Stack.push_back(Exported);
4330 getContext().mergeDefinitionIntoModule(
4333 PendingMergedDefinitionsToDeduplicate.insert(Def);
4342 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4343 !PP.getLangOpts().Modules)
4347 TriedLoadingGlobalIndex =
true;
4348 StringRef ModuleCachePath
4349 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4350 std::pair<GlobalModuleIndex *, llvm::Error>
Result =
4352 if (llvm::Error Err = std::move(
Result.second)) {
4354 consumeError(std::move(Err));
4358 GlobalIndex.reset(
Result.first);
4359 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4364 return PP.getLangOpts().Modules && UseGlobalIndex &&
4365 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4372 llvm::raw_fd_ostream OS(TimestampFilename, EC,
4373 llvm::sys::fs::OF_TextWithCRLF);
4376 OS <<
"Timestamp file\n";
4389 consumeError(MaybeEntry.takeError());
4392 llvm::BitstreamEntry Entry = MaybeEntry.get();
4394 switch (Entry.Kind) {
4395 case llvm::BitstreamEntry::Error:
4396 case llvm::BitstreamEntry::EndBlock:
4399 case llvm::BitstreamEntry::Record:
4405 consumeError(Skipped.takeError());
4409 case llvm::BitstreamEntry::SubBlock:
4410 if (Entry.ID == BlockID) {
4411 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4413 consumeError(std::move(Err));
4420 if (llvm::Error Err = Cursor.SkipBlock()) {
4422 consumeError(std::move(Err));
4431 unsigned ClientLoadCapabilities,
4433 llvm::TimeTraceScope scope(
"ReadAST",
FileName);
4437 CurrentDeserializingModuleKind,
Type);
4443 unsigned PreviousGeneration = 0;
4445 PreviousGeneration = incrementGeneration(*ContextObj);
4447 unsigned NumModules = ModuleMgr.size();
4452 ClientLoadCapabilities)) {
4453 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules);
4457 GlobalIndex.reset();
4458 ModuleMgr.setGlobalIndex(
nullptr);
4462 if (NewLoadedModuleFile && !Loaded.empty())
4463 *NewLoadedModuleFile = Loaded.back().Mod;
4474 for (ImportedModule &M : Loaded) {
4476 llvm::TimeTraceScope Scope2(
"Read Loaded AST", F.
ModuleName);
4479 if (llvm::Error Err = ReadASTBlock(F, ClientLoadCapabilities)) {
4480 Error(std::move(Err));
4486 Error(diag::err_module_file_missing_top_level_submodule, F.
FileName);
4492 if (llvm::Error Err = ReadExtensionBlock(F)) {
4493 Error(std::move(Err));
4506 for (ImportedModule &M : Loaded) {
4522 if (!PP.getLangOpts().CPlusPlus) {
4529 auto It = PP.getIdentifierTable().find(Key);
4530 if (It == PP.getIdentifierTable().end())
4539 II = &PP.getIdentifierTable().getOwn(Key);
4550 SetIdentifierInfo(ID, II);
4557 for (
auto &
Id : PP.getIdentifierTable())
4558 Id.second->setOutOfDate(
true);
4561 for (
const auto &Sel : SelectorGeneration)
4562 SelectorOutOfDate[Sel.first] =
true;
4566 for (ImportedModule &M : Loaded) {
4569 ModuleMgr.moduleFileAccepted(&F);
4578 F.
ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4582 for (
unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4583 UnresolvedModuleRef &
Unresolved = UnresolvedModuleRefs[I];
4585 Module *ResolvedMod = getSubmodule(GlobalID);
4588 case UnresolvedModuleRef::Conflict:
4591 Conflict.
Other = ResolvedMod;
4593 Unresolved.Mod->Conflicts.push_back(Conflict);
4597 case UnresolvedModuleRef::Import:
4602 case UnresolvedModuleRef::Affecting:
4604 Unresolved.Mod->AffectingClangModules.insert(ResolvedMod);
4607 case UnresolvedModuleRef::Export:
4614 UnresolvedModuleRefs.clear();
4621 InitializeContext();
4626 if (DeserializationListener)
4627 DeserializationListener->ReaderInitialized(
this);
4629 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4644 for (
unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4645 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4646 ObjCClassesLoaded[I], PreviousGeneration);
4655 for (
unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4656 ImportedModule &M = Loaded[I];
4673 if (!Stream.canSkipToPos(4))
4674 return llvm::createStringError(std::errc::illegal_byte_sequence,
4675 "file too small to contain AST file magic");
4676 for (
unsigned C : {
'C',
'P',
'C',
'H'})
4679 return llvm::createStringError(
4680 std::errc::illegal_byte_sequence,
4681 "file doesn't start with AST file magic");
4683 return Res.takeError();
4684 return llvm::Error::success();
4699 llvm_unreachable(
"unknown module kind");
4703ASTReader::ReadASTCore(StringRef
FileName,
4708 off_t ExpectedSize, time_t ExpectedModTime,
4710 unsigned ClientLoadCapabilities) {
4712 std::string ErrorStr;
4714 = ModuleMgr.addModule(
FileName,
Type, ImportLoc, ImportedBy,
4715 getGeneration(), ExpectedSize, ExpectedModTime,
4719 switch (AddResult) {
4721 Diag(diag::remark_module_import)
4723 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
4733 if (ClientLoadCapabilities & ARR_Missing)
4737 Diag(diag::err_ast_file_not_found)
4745 if (ClientLoadCapabilities & ARR_OutOfDate)
4749 Diag(diag::err_ast_file_out_of_date)
4755 assert(M &&
"Missing module file");
4757 bool ShouldFinalizePCM =
false;
4758 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4759 auto &MC = getModuleManager().getModuleCache();
4760 if (ShouldFinalizePCM)
4766 BitstreamCursor &Stream = F.
Stream;
4767 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4768 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4772 Diag(diag::err_ast_file_invalid)
4778 bool HaveReadControlBlock =
false;
4782 Error(MaybeEntry.takeError());
4785 llvm::BitstreamEntry Entry = MaybeEntry.get();
4787 switch (Entry.Kind) {
4788 case llvm::BitstreamEntry::Error:
4789 case llvm::BitstreamEntry::Record:
4790 case llvm::BitstreamEntry::EndBlock:
4791 Error(
"invalid record at top-level of AST file");
4794 case llvm::BitstreamEntry::SubBlock:
4800 HaveReadControlBlock =
true;
4801 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4809 F.ModuleName.empty()) {
4811 if (
Result != OutOfDate ||
4812 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4818 case Failure:
return Failure;
4819 case Missing:
return Missing;
4820 case OutOfDate:
return OutOfDate;
4822 case ConfigurationMismatch:
return ConfigurationMismatch;
4823 case HadErrors:
return HadErrors;
4828 if (!HaveReadControlBlock) {
4829 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4830 Diag(diag::err_pch_version_too_old);
4835 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4836 ShouldFinalizePCM =
true;
4840 if (llvm::Error Err = Stream.SkipBlock()) {
4841 Error(std::move(Err));
4848 llvm_unreachable(
"unexpected break; expected return");
4852ASTReader::readUnhashedControlBlock(
ModuleFile &F,
bool WasImportedBy,
4853 unsigned ClientLoadCapabilities) {
4855 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4856 bool AllowCompatibleConfigurationMismatch =
4858 bool DisableValidation = shouldDisableValidationForFile(F);
4860 ASTReadResult
Result = readUnhashedControlBlockImpl(
4861 &F, F.
Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4867 if (DisableValidation || WasImportedBy ||
4868 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
4872 Error(
"malformed block record in AST file");
4895 if (getModuleManager().getModuleCache().isPCMFinal(F.
FileName)) {
4896 Diag(diag::warn_module_system_bit_conflict) << F.
FileName;
4905 ModuleFile *F, llvm::StringRef StreamData,
unsigned ClientLoadCapabilities,
4907 bool ValidateDiagnosticOptions) {
4909 BitstreamCursor Stream(StreamData);
4914 consumeError(std::move(Err));
4929 consumeError(MaybeEntry.takeError());
4932 llvm::BitstreamEntry Entry = MaybeEntry.get();
4934 switch (Entry.Kind) {
4935 case llvm::BitstreamEntry::Error:
4936 case llvm::BitstreamEntry::SubBlock:
4939 case llvm::BitstreamEntry::EndBlock:
4942 case llvm::BitstreamEntry::Record:
4951 Stream.readRecord(Entry.ID,
Record, &Blob);
4952 if (!MaybeRecordType) {
4961 "Dummy AST file signature not backpatched in ASTWriter.");
4968 "Dummy AST block hash not backpatched in ASTWriter.");
4972 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4973 if (Listener && ValidateDiagnosticOptions &&
4974 !AllowCompatibleConfigurationMismatch &&
4975 ParseDiagnosticOptions(
Record, Complain, *Listener))
4980 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
4981 if (Listener && !AllowCompatibleConfigurationMismatch &&
4982 ParseHeaderSearchPaths(
Record, Complain, *Listener))
4983 Result = ConfigurationMismatch;
5012 if (
Record.size() < 4)
return true;
5017 unsigned BlockNameLen =
Record[2];
5018 unsigned UserInfoLen =
Record[3];
5020 if (BlockNameLen + UserInfoLen > Blob.size())
return true;
5022 Metadata.
BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
5023 Metadata.
UserInfo = std::string(Blob.data() + BlockNameLen,
5024 Blob.data() + BlockNameLen + UserInfoLen);
5028llvm::Error ASTReader::ReadExtensionBlock(
ModuleFile &F) {
5029 BitstreamCursor &Stream = F.
Stream;
5035 return MaybeEntry.takeError();
5036 llvm::BitstreamEntry Entry = MaybeEntry.get();
5038 switch (Entry.Kind) {
5039 case llvm::BitstreamEntry::SubBlock:
5040 if (llvm::Error Err = Stream.SkipBlock())
5043 case llvm::BitstreamEntry::EndBlock:
5044 return llvm::Error::success();
5045 case llvm::BitstreamEntry::Error:
5046 return llvm::createStringError(std::errc::illegal_byte_sequence,
5047 "malformed block record in AST file");
5048 case llvm::BitstreamEntry::Record:
5055 Stream.readRecord(Entry.ID,
Record, &Blob);
5057 return MaybeRecCode.takeError();
5058 switch (MaybeRecCode.get()) {
5062 return llvm::createStringError(
5063 std::errc::illegal_byte_sequence,
5064 "malformed EXTENSION_METADATA in AST file");
5067 auto Known = ModuleFileExtensions.find(Metadata.
BlockName);
5068 if (Known == ModuleFileExtensions.end())
break;
5071 if (
auto Reader = Known->second->createExtensionReader(Metadata, *
this,
5081 return llvm::Error::success();
5085 assert(ContextObj &&
"no context to initialize");
5089 if (DeserializationListener)
5090 DeserializationListener->DeclRead(
5100 if (!Context.CFConstantStringTypeDecl)
5107 Error(
"FILE type is NULL");
5111 if (!Context.FILEDecl) {
5117 Error(
"Invalid FILE type in AST file");
5126 QualType Jmp_bufType = GetType(Jmp_buf);
5127 if (Jmp_bufType.
isNull()) {
5128 Error(
"jmp_buf type is NULL");
5132 if (!Context.jmp_bufDecl) {
5138 Error(
"Invalid jmp_buf type in AST file");
5147 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
5148 if (Sigjmp_bufType.
isNull()) {
5149 Error(
"sigjmp_buf type is NULL");
5153 if (!Context.sigjmp_bufDecl) {
5158 assert(Tag &&
"Invalid sigjmp_buf type in AST file");
5165 if (Context.ObjCIdRedefinitionType.
isNull())
5166 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
5169 if (
TypeID ObjCClassRedef =
5171 if (Context.ObjCClassRedefinitionType.
isNull())
5172 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
5175 if (
TypeID ObjCSelRedef =
5177 if (Context.ObjCSelRedefinitionType.
isNull())
5178 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
5182 QualType Ucontext_tType = GetType(Ucontext_t);
5183 if (Ucontext_tType.
isNull()) {
5184 Error(
"ucontext_t type is NULL");
5188 if (!Context.ucontext_tDecl) {
5193 assert(Tag &&
"Invalid ucontext_t type in AST file");
5203 if (!CUDASpecialDeclRefs.empty()) {
5204 assert(CUDASpecialDeclRefs.size() == 1 &&
"More decl refs than expected!");
5206 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5211 for (
auto &Import : PendingImportedModules) {
5212 if (
Module *Imported = getSubmodule(Import.ID)) {
5215 if (Import.ImportLoc.isValid())
5216 PP.makeModuleVisible(Imported, Import.ImportLoc);
5223 PendingImportedModulesSema.append(PendingImportedModules);
5224 PendingImportedModules.clear();
5234 BitstreamCursor Stream(
PCH);
5237 consumeError(std::move(Err));
5249 Stream.advanceSkippingSubblocks();
5252 consumeError(MaybeEntry.takeError());
5255 llvm::BitstreamEntry Entry = MaybeEntry.get();
5257 if (Entry.Kind != llvm::BitstreamEntry::Record)
5265 consumeError(MaybeRecord.takeError());
5271 "Dummy AST file signature not backpatched in ASTWriter.");
5281 const std::string &ASTFileName,
FileManager &FileMgr,
5287 Diags.
Report(diag::err_fe_unable_to_read_pch_file)
5288 << ASTFileName << Buffer.getError().message();
5289 return std::string();
5293 BitstreamCursor Stream(PCHContainerRdr.
ExtractPCH(**Buffer));
5297 Diags.
Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5298 return std::string();
5303 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5304 return std::string();
5311 Stream.advanceSkippingSubblocks();
5314 consumeError(MaybeEntry.takeError());
5315 return std::string();
5317 llvm::BitstreamEntry Entry = MaybeEntry.get();
5319 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5320 return std::string();
5322 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5323 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5324 return std::string();
5332 consumeError(MaybeRecord.takeError());
5333 return std::string();
5346 std::string ExistingModuleCachePath;
5348 bool StrictOptionMatches;
5351 SimplePCHValidator(
const LangOptions &ExistingLangOpts,
5354 StringRef ExistingModuleCachePath,
FileManager &FileMgr,
5355 bool StrictOptionMatches)
5356 : ExistingLangOpts(ExistingLangOpts),
5357 ExistingTargetOpts(ExistingTargetOpts),
5358 ExistingPPOpts(ExistingPPOpts),
5359 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr),
5360 StrictOptionMatches(StrictOptionMatches) {}
5362 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
5363 bool AllowCompatibleDifferences)
override {
5365 AllowCompatibleDifferences);
5368 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
5369 bool AllowCompatibleDifferences)
override {
5371 AllowCompatibleDifferences);
5375 StringRef SpecificModuleCachePath,
5376 bool Complain)
override {
5379 ExistingModuleCachePath,
nullptr, ExistingLangOpts, ExistingPPOpts);
5383 bool ReadMacros,
bool Complain,
5384 std::string &SuggestedPredefines)
override {
5386 PPOpts, ExistingPPOpts, ReadMacros,
nullptr, FileMgr,
5387 SuggestedPredefines, ExistingLangOpts,
5400 unsigned ClientLoadCapabilities) {
5402 std::unique_ptr<llvm::MemoryBuffer> OwnedBuffer;
5414 OwnedBuffer = std::move(*BufferOrErr);
5415 Buffer = OwnedBuffer.get();
5419 StringRef Bytes = PCHContainerRdr.
ExtractPCH(*Buffer);
5420 BitstreamCursor Stream(Bytes);
5424 consumeError(std::move(Err));
5435 BitstreamCursor InputFilesCursor;
5436 uint64_t InputFilesOffsetBase = 0;
5439 std::string ModuleDir;
5440 bool DoneWithControlBlock =
false;
5441 while (!DoneWithControlBlock) {
5445 consumeError(MaybeEntry.takeError());
5448 llvm::BitstreamEntry Entry = MaybeEntry.get();
5450 switch (Entry.Kind) {
5451 case llvm::BitstreamEntry::SubBlock: {
5454 std::string IgnoredSuggestedPredefines;
5455 if (ReadOptionsBlock(Stream, ClientLoadCapabilities,
5457 Listener, IgnoredSuggestedPredefines) !=
Success)
5463 InputFilesCursor = Stream;
5464 if (llvm::Error Err = Stream.SkipBlock()) {
5466 consumeError(std::move(Err));
5469 if (NeedsInputFiles &&
5472 InputFilesOffsetBase = InputFilesCursor.GetCurrentBitNo();
5476 if (llvm::Error Err = Stream.SkipBlock()) {
5478 consumeError(std::move(Err));
5487 case llvm::BitstreamEntry::EndBlock:
5488 DoneWithControlBlock =
true;
5491 case llvm::BitstreamEntry::Error:
5494 case llvm::BitstreamEntry::Record:
5498 if (DoneWithControlBlock)
break;
5503 Stream.readRecord(Entry.ID,
Record, &Blob);
5504 if (!MaybeRecCode) {
5519 ModuleDir = std::string(Blob);
5524 ResolveImportedPath(
Path, ModuleDir);
5529 if (!NeedsInputFiles)
5532 unsigned NumInputFiles =
Record[0];
5533 unsigned NumUserFiles =
Record[1];
5534 const llvm::support::unaligned_uint64_t *InputFileOffs =
5535 (
const llvm::support::unaligned_uint64_t *)Blob.data();
5536 for (
unsigned I = 0; I != NumInputFiles; ++I) {
5538 bool isSystemFile = I >= NumUserFiles;
5540 if (isSystemFile && !NeedsSystemInputFiles)
5543 BitstreamCursor &Cursor = InputFilesCursor;
5545 if (llvm::Error Err =
5546 Cursor.JumpToBit(InputFilesOffsetBase + InputFileOffs[I])) {
5548 consumeError(std::move(Err));
5554 consumeError(MaybeCode.takeError());
5556 unsigned Code = MaybeCode.get();
5560 bool shouldContinue =
false;
5562 Cursor.readRecord(Code,
Record, &Blob);
5563 if (!MaybeRecordType) {
5565 consumeError(MaybeRecordType.takeError());
5571 bool Overridden =
static_cast<bool>(
Record[3]);
5572 std::string
Filename = std::string(Blob);
5573 ResolveImportedPath(
Filename, ModuleDir);
5575 Filename, isSystemFile, Overridden,
false);
5578 if (!shouldContinue)
5588 unsigned Idx = 0, N =
Record.size();
5594 bool IsStandardCXXModule =
Record[Idx++];
5601 if (IsStandardCXXModule) {
5602 std::string ModuleName = ReadString(
Record, Idx);
5609 std::string ModuleName = ReadString(
Record, Idx);
5611 ResolveImportedPath(
Filename, ModuleDir);
5624 if (FindModuleFileExtensions) {
5625 BitstreamCursor SavedStream = Stream;
5627 bool DoneWithExtensionBlock =
false;
5628 while (!DoneWithExtensionBlock) {
5634 llvm::BitstreamEntry Entry = MaybeEntry.get();
5636 switch (Entry.Kind) {
5637 case llvm::BitstreamEntry::SubBlock:
5638 if (llvm::Error Err = Stream.SkipBlock()) {
5640 consumeError(std::move(Err));
5645 case llvm::BitstreamEntry::EndBlock:
5646 DoneWithExtensionBlock =
true;
5649 case llvm::BitstreamEntry::Error:
5652 case llvm::BitstreamEntry::Record:
5659 Stream.readRecord(Entry.ID,
Record, &Blob);
5660 if (!MaybeRecCode) {
5664 switch (MaybeRecCode.get()) {
5676 Stream = SavedStream;
5680 if (readUnhashedControlBlockImpl(
5681 nullptr, Bytes, ClientLoadCapabilities,
5683 ValidateDiagnosticOptions) !=
Success)
5695 StringRef ExistingModuleCachePath,
5696 bool RequireStrictOptionMatches) {
5697 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
5698 ExistingModuleCachePath, FileMgr,
5699 RequireStrictOptionMatches);
5700 return !readASTFileControlBlock(
Filename, FileMgr, ModuleCache,
5706llvm::Error ASTReader::ReadSubmoduleBlock(
ModuleFile &F,
5707 unsigned ClientLoadCapabilities) {
5712 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5714 Module *CurrentModule =
nullptr;
5718 F.
Stream.advanceSkippingSubblocks();
5720 return MaybeEntry.takeError();
5721 llvm::BitstreamEntry Entry = MaybeEntry.get();
5723 switch (Entry.Kind) {
5724 case llvm::BitstreamEntry::SubBlock:
5725 case llvm::BitstreamEntry::Error:
5726 return llvm::createStringError(std::errc::illegal_byte_sequence,
5727 "malformed block record in AST file");
5728 case llvm::BitstreamEntry::EndBlock:
5729 return llvm::Error::success();
5730 case llvm::BitstreamEntry::Record:
5740 return MaybeKind.takeError();
5741 unsigned Kind = MaybeKind.get();
5744 return llvm::createStringError(
5745 std::errc::illegal_byte_sequence,
5746 "submodule metadata record should be at beginning of block");
5761 return llvm::createStringError(std::errc::illegal_byte_sequence,
5762 "malformed module definition");
5764 StringRef Name = Blob;
5770 bool IsFramework =
Record[Idx++];
5771 bool IsExplicit =
Record[Idx++];
5772 bool IsSystem =
Record[Idx++];
5773 bool IsExternC =
Record[Idx++];
5774 bool InferSubmodules =
Record[Idx++];
5775 bool InferExplicitSubmodules =
Record[Idx++];
5776 bool InferExportWildcard =
Record[Idx++];
5777 bool ConfigMacrosExhaustive =
Record[Idx++];
5778 bool ModuleMapIsPrivate =
Record[Idx++];
5779 bool NamedModuleHasInit =
Record[Idx++];
5781 Module *ParentModule =
nullptr;
5783 ParentModule = getSubmodule(
Parent);
5794 if (GlobalIndex >= SubmodulesLoaded.size() ||
5795 SubmodulesLoaded[GlobalIndex])
5796 return llvm::createStringError(std::errc::invalid_argument,
5797 "too many submodules");
5799 if (!ParentModule) {
5802 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
5804 CurFile != F.
File) {
5805 auto ConflictError =
5807 ContextObj->DiagAllocator)
5831 if (DeserializationListener)
5832 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5834 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5859 std::string
Filename = std::string(Blob);
5861 if (
auto Umbrella = PP.getFileManager().getOptionalFileRef(
Filename)) {
5889 std::string HeaderName(Blob);
5890 ResolveImportedPath(F, HeaderName);
5897 std::string Dirname = std::string(Blob);
5898 ResolveImportedPath(F, Dirname);
5900 PP.getFileManager().getOptionalDirectoryRef(Dirname)) {
5912 unsigned LocalBaseSubmoduleID =
Record[1];
5916 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5921 std::make_pair(LocalBaseSubmoduleID,
5930 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5935 Unresolved.Kind = UnresolvedModuleRef::Import;
5942 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5947 Unresolved.Kind = UnresolvedModuleRef::Affecting;
5954 for (
unsigned Idx = 0; Idx + 1 <
Record.size(); Idx += 2) {
5959 Unresolved.Kind = UnresolvedModuleRef::Export;
5971 PP.getTargetInfo());
5989 Unresolved.Kind = UnresolvedModuleRef::Conflict;
6000 for (
unsigned I = 0; I <
Record.size(); )
6001 Inits.push_back(ReadDeclID(F,
Record, I));
6002 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
6021bool ASTReader::ParseLanguageOptions(
const RecordData &
Record,
6024 bool AllowCompatibleDifferences) {
6027#define LANGOPT(Name, Bits, Default, Description) \
6028 LangOpts.Name = Record[Idx++];
6029#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
6030 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
6031#include "clang/Basic/LangOptions.def"
6032#define SANITIZER(NAME, ID) \
6033 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
6034#include "clang/Basic/Sanitizers.def"
6036 for (
unsigned N =
Record[Idx++]; N; --N)
6040 VersionTuple runtimeVersion = ReadVersionTuple(
Record, Idx);
6046 for (
unsigned N =
Record[Idx++]; N; --N) {
6048 ReadString(
Record, Idx));
6053 for (
unsigned N =
Record[Idx++]; N; --N) {
6060 AllowCompatibleDifferences);
6063bool ASTReader::ParseTargetOptions(
const RecordData &
Record,
bool Complain,
6065 bool AllowCompatibleDifferences) {
6069 TargetOpts.
CPU = ReadString(
Record, Idx);
6071 TargetOpts.
ABI = ReadString(
Record, Idx);
6072 for (
unsigned N =
Record[Idx++]; N; --N) {
6075 for (
unsigned N =
Record[Idx++]; N; --N) {
6080 AllowCompatibleDifferences);
6083bool ASTReader::ParseDiagnosticOptions(
const RecordData &
Record,
bool Complain,
6087#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
6088#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
6089 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
6090#include "clang/Basic/DiagnosticOptions.def"
6092 for (
unsigned N =
Record[Idx++]; N; --N)
6093 DiagOpts->Warnings.push_back(ReadString(
Record, Idx));
6094 for (
unsigned N =
Record[Idx++]; N; --N)
6095 DiagOpts->Remarks.push_back(ReadString(
Record, Idx));
6100bool ASTReader::ParseFileSystemOptions(
const RecordData &
Record,
bool Complain,
6108bool ASTReader::ParseHeaderSearchOptions(
const RecordData &
Record,
6126 std::string SpecificModuleCachePath = ReadString(
Record, Idx);
6132bool ASTReader::ParseHeaderSearchPaths(
const RecordData &
Record,
bool Complain,
6138 for (
unsigned N =
Record[Idx++]; N; --N) {
6142 bool IsFramework =
Record[Idx++];
6143 bool IgnoreSysRoot =
Record[Idx++];
6149 for (
unsigned N =
Record[Idx++]; N; --N) {
6150 std::string Prefix = ReadString(
Record, Idx);
6151 bool IsSystemHeader =
Record[Idx++];
6156 for (
unsigned N =
Record[Idx++]; N; --N) {
6157 std::string VFSOverlayFile = ReadString(
Record, Idx);
6164bool ASTReader::ParsePreprocessorOptions(
const RecordData &
Record,
6167 std::string &SuggestedPredefines) {
6172 bool ReadMacros =
Record[Idx++];
6174 for (
unsigned N =
Record[Idx++]; N; --N) {
6176 bool IsUndef =
Record[Idx++];
6177 PPOpts.
Macros.push_back(std::make_pair(Macro, IsUndef));
6182 for (
unsigned N =
Record[Idx++]; N; --N) {
6187 for (
unsigned N =
Record[Idx++]; N; --N) {
6196 SuggestedPredefines.clear();
6198 SuggestedPredefines);
6201std::pair<ModuleFile *, unsigned>
6202ASTReader::getModulePreprocessedEntity(
unsigned GlobalIndex) {
6203 GlobalPreprocessedEntityMapType::iterator
6204 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
6205 assert(I != GlobalPreprocessedEntityMap.end() &&
6206 "Corrupted global preprocessed entity map");
6209 return std::make_pair(M, LocalIndex);
6212llvm::iterator_range<PreprocessingRecord::iterator>
6213ASTReader::getModulePreprocessedEntities(
ModuleFile &Mod)
const {
6222bool ASTReader::canRecoverFromOutOfDate(StringRef ModuleFileName,
6223 unsigned int ClientLoadCapabilities) {
6224 return ClientLoadCapabilities & ARR_OutOfDate &&
6225 !getModuleManager().getModuleCache().isPCMFinal(ModuleFileName);
6228llvm::iterator_range<ASTReader::ModuleDeclIterator>
6230 return llvm::make_range(
6237 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
6238 assert(I != GlobalSkippedRangeMap.end() &&
6239 "Corrupted global skipped range map");
6242 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
6245 ReadSourceLocation(*M, RawRange.
getEnd()));
6252 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6254 unsigned LocalIndex = PPInfo.second;
6257 if (!PP.getPreprocessingRecord()) {
6258 Error(
"no preprocessing record");
6265 Error(std::move(Err));
6272 Error(MaybeEntry.takeError());
6275 llvm::BitstreamEntry Entry = MaybeEntry.get();
6277 if (Entry.Kind != llvm::BitstreamEntry::Record)
6282 ReadSourceLocation(M, PPOffs.
getEnd()));
6288 if (!MaybeRecType) {
6289 Error(MaybeRecType.takeError());
6294 bool isBuiltin =
Record[0];
6298 Name = getLocalIdentifier(M,
Record[1]);
6301 getGlobalPreprocessedEntityID(M,
Record[1]);
6302 Def = cast<MacroDefinitionRecord>(
6303 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
6321 if (DeserializationListener)
6322 DeserializationListener->MacroDefinitionRead(PPID, MD);
6328 const char *FullFileNameStart = Blob.data() +
Record[0];
6329 StringRef FullFileName(FullFileNameStart, Blob.size() -
Record[0]);
6331 if (!FullFileName.empty())
6332 File = PP.getFileManager().getOptionalFileRef(FullFileName);
6339 StringRef(Blob.data(),
Record[0]),
6347 llvm_unreachable(
"Invalid PreprocessorDetailRecordTypes");
6357 GlobalSLocOffsetMapType::const_iterator SLocMapI)
const {
6359 for (GlobalSLocOffsetMapType::const_iterator
6360 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
6366 return getTotalNumPreprocessedEntities();
6371struct PPEntityComp {
6401 bool EndsAfter)
const {
6402 if (SourceMgr.isLocalSourceLocation(
Loc))
6403 return getTotalNumPreprocessedEntities();
6405 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
6406 SourceManager::MaxLoadedOffset -
Loc.getOffset() - 1);
6407 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
6408 "Corrupted global sloc offset map");
6410 if (SLocMapI->second->NumPreprocessedEntities == 0)
6411 return findNextPreprocessedEntity(SLocMapI);
6422 pp_iterator
First = pp_begin;
6426 PPI = std::upper_bound(pp_begin, pp_end,
Loc,
6427 PPEntityComp(*
this, M));
6436 std::advance(PPI,
Half);
6437 if (SourceMgr.isBeforeInTranslationUnit(
6438 ReadSourceLocation(M, PPI->getEnd()),
Loc)) {
6441 Count = Count -
Half - 1;
6448 return findNextPreprocessedEntity(SLocMapI);
6455std::pair<unsigned, unsigned>
6458 return std::make_pair(0,0);
6464 return std::make_pair(BeginID, EndID);
6474 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6476 unsigned LocalIndex = PPInfo.second;
6483 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(
Loc), FID))
6492 class HeaderFileInfoVisitor {
6494 std::optional<HeaderFileInfo> HFI;
6497 explicit HeaderFileInfoVisitor(
FileEntryRef FE) : FE(FE) {}
6506 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
6507 if (Pos == Table->end())
6514 std::optional<HeaderFileInfo> getHeaderFileInfo()
const {
return HFI; }
6520 HeaderFileInfoVisitor Visitor(FE);
6521 ModuleMgr.visit(Visitor);
6522 if (std::optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
6529 using DiagState = DiagnosticsEngine::DiagState;
6540 auto ReadDiagState = [&](
const DiagState &BasedOn,
6541 bool IncludeNonPragmaStates) {
6542 unsigned BackrefID =
Record[Idx++];
6544 return DiagStates[BackrefID - 1];
6547 Diag.DiagStates.push_back(BasedOn);
6548 DiagState *NewState = &
Diag.DiagStates.back();
6549 DiagStates.push_back(NewState);
6550 unsigned Size =
Record[Idx++];
6551 assert(Idx + Size * 2 <=
Record.size() &&
6552 "Invalid data, not enough diag/map pairs");
6554 unsigned DiagID =
Record[Idx++];
6557 if (!NewMapping.
isPragma() && !IncludeNonPragmaStates)
6570 Mapping = NewMapping;
6576 DiagState *FirstState;
6581 FirstState =
Diag.DiagStatesByLoc.FirstDiagState;
6582 DiagStates.push_back(FirstState);
6586 "Invalid data, unexpected backref in initial state");
6588 assert(Idx <
Record.size() &&
6589 "Invalid data, not enough state change pairs in initial state");
6594 unsigned Flags =
Record[Idx++];
6596 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
6597 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
6598 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
6599 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
6600 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
6602 FirstState = ReadDiagState(Initial,
true);
6610 .StateTransitions.push_back({FirstState, 0});
6615 FirstState = ReadDiagState(*
Diag.DiagStatesByLoc.CurDiagState,
false);
6619 unsigned NumLocations =
Record[Idx++];
6620 while (NumLocations--) {
6621 assert(Idx <
Record.size() &&
6622 "Invalid data, missing pragma diagnostic states");
6624 assert(FID.
isValid() &&
"invalid FileID for transition");
6625 unsigned Transitions =
Record[Idx++];
6631 auto &F =
Diag.DiagStatesByLoc.Files[FID];
6632 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
6633 for (
unsigned I = 0; I != Transitions; ++I) {
6634 unsigned Offset =
Record[Idx++];
6635 auto *State = ReadDiagState(*FirstState,
false);
6636 F.StateTransitions.push_back({State, Offset});
6641 assert(Idx <
Record.size() &&
6642 "Invalid data, missing final pragma diagnostic state");
6644 auto *CurState = ReadDiagState(*FirstState,
false);
6647 Diag.DiagStatesByLoc.CurDiagState = CurState;
6648 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
6653 auto &
T =
Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
6655 T.push_back({CurState, 0});
6657 T[0].State = CurState;
6666ASTReader::RecordLocation ASTReader::TypeCursorForIndex(
TypeID ID) {
6667 auto [M, Index] = translateTypeIDToIndex(ID);
6674#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
6675 case TYPE_##CODE_ID: return Type::CLASS_ID;
6676#include "clang/Serialization/TypeBitCodes.def"
6678 return std::nullopt;
6689 assert(ContextObj &&
"reading type with no AST context");
6691 RecordLocation
Loc = TypeCursorForIndex(ID);
6692 BitstreamCursor &DeclsCursor =
Loc.F->DeclsCursor;
6698 ReadingKindTracker ReadingKind(Read_Type, *
this);
6701 Deserializing AType(
this);
6703 if (llvm::Error Err = DeclsCursor.JumpToBit(
Loc.Offset)) {
6704 Error(std::move(Err));
6709 Error(RawCode.takeError());
6716 Error(Code.takeError());
6727 Error(
"Unexpected code for type");
6732 return TypeReader.read(*maybeClass);
6760 : Reader(Reader),
Seq(
Seq) {}
6765#define ABSTRACT_TYPELOC(CLASS, PARENT)
6766#define TYPELOC(CLASS, PARENT) \
6767 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6768#include "clang/AST/TypeLocNodes.def"
6834 if (Reader.readBool())
6841 VisitArrayTypeLoc(TL);
6845 VisitArrayTypeLoc(TL);
6849 VisitArrayTypeLoc(TL);
6852void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6854 VisitArrayTypeLoc(TL);
6857void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6865void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6874void TypeLocReader::VisitDependentVectorTypeLoc(
6890void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
6904 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i) {
6910 VisitFunctionTypeLoc(TL);
6914 VisitFunctionTypeLoc(TL);
6921void TypeLocReader::VisitUsingTypeLoc(
UsingTypeLoc TL) {
6959 auto NNS = readNestedNameSpecifierLoc();
6960 auto TemplateKWLoc = readSourceLocation();
6961 auto ConceptNameLoc = readDeclarationNameInfo();
6962 auto FoundDecl = readDeclAs<NamedDecl>();
6963 auto NamedConcept = readDeclAs<ConceptDecl>();
6965 getContext(), NNS, TemplateKWLoc, ConceptNameLoc, FoundDecl, NamedConcept,
6966 (readBool() ? readASTTemplateArgumentListInfo() :
nullptr));
6970void TypeLocReader::VisitAutoTypeLoc(
AutoTypeLoc TL) {
6972 if (Reader.readBool())
6974 if (Reader.readBool())
6978void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6987void TypeLocReader::VisitEnumTypeLoc(
EnumTypeLoc TL) {
7007void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
7012void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
7017void TypeLocReader::VisitTemplateSpecializationTypeLoc(
7023 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
7025 Reader.readTemplateArgumentLocInfo(
7029void TypeLocReader::VisitParenTypeLoc(
ParenTypeLoc TL) {
7049void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
7059 Reader.readTemplateArgumentLocInfo(
7103void TypeLocReader::VisitPipeTypeLoc(
PipeTypeLoc TL) {
7110void TypeLocReader::VisitDependentBitIntTypeLoc(
7127 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
7146std::pair<ModuleFile *, unsigned>
7149 "Predefined type shouldn't be in TypesLoaded");
7151 assert(ModuleFileIndex &&
"Untranslated Local Decl?");
7153 ModuleFile *OwningModuleFile = &getModuleManager()[ModuleFileIndex - 1];
7154 assert(OwningModuleFile &&
7155 "untranslated type ID or local type ID shouldn't be in TypesLoaded");
7157 return {OwningModuleFile,
7162 assert(ContextObj &&
"reading type with no AST context");
7173 llvm_unreachable(
"Invalid predefined type");
7362#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7363 case PREDEF_TYPE_##Id##_ID: \
7364 T = Context.SingletonId; \
7366#include "clang/Basic/OpenCLImageTypes.def"
7367#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7368 case PREDEF_TYPE_##Id##_ID: \
7369 T = Context.Id##Ty; \
7371#include "clang/Basic/OpenCLExtensionTypes.def"
7411#define SVE_TYPE(Name, Id, SingletonId) \
7412 case PREDEF_TYPE_##Id##_ID: \
7413 T = Context.SingletonId; \
7415#include "clang/Basic/AArch64SVEACLETypes.def"
7416#define PPC_VECTOR_TYPE(Name, Id, Size) \
7417 case PREDEF_TYPE_##Id##_ID: \
7418 T = Context.Id##Ty; \
7420#include "clang/Basic/PPCTypes.def"
7421#define RVV_TYPE(Name, Id, SingletonId) \
7422 case PREDEF_TYPE_##Id##_ID: \
7423 T = Context.SingletonId; \
7425#include "clang/Basic/RISCVVTypes.def"
7426#define WASM_TYPE(Name, Id, SingletonId) \
7427 case PREDEF_TYPE_##Id##_ID: \
7428 T = Context.SingletonId; \
7430#include "clang/Basic/WebAssemblyReferenceTypes.def"
7431#define AMDGPU_TYPE(Name, Id, SingletonId) \
7432 case PREDEF_TYPE_##Id##_ID: \
7433 T = Context.SingletonId; \
7435#include "clang/Basic/AMDGPUTypes.def"
7438 assert(!
T.isNull() &&
"Unknown predefined type");
7439 return T.withFastQualifiers(FastQuals);
7442 unsigned Index = translateTypeIDToIndex(ID).second;
7444 assert(Index < TypesLoaded.size() &&
"Type index out-of-range");
7445 if (TypesLoaded[Index].isNull()) {
7446 TypesLoaded[Index] = readTypeRecord(ID);
7447 if (TypesLoaded[Index].isNull())
7450 TypesLoaded[Index]->setFromAST();
7451 if (DeserializationListener)
7453 TypesLoaded[Index]);
7456 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7460 return GetType(getGlobalTypeID(F, LocalID));
7469 ReadModuleOffsetMap(F);
7472 LocalID &= llvm::maskTrailingOnes<TypeID>(32);
7474 if (ModuleFileIndex == 0)
7479 ModuleFileIndex = MF.
Index + 1;
7480 return ((uint64_t)ModuleFileIndex << 32) | LocalID;
7489 return readTypeSourceInfo();
7492 readNestedNameSpecifierLoc();
7502 TemplateNameLoc, EllipsisLoc);
7513 llvm_unreachable(
"unexpected template argument loc");
7528 Result.setLAngleLoc(readSourceLocation());
7529 Result.setRAngleLoc(readSourceLocation());
7530 unsigned NumArgsAsWritten = readInt();
7531 for (
unsigned i = 0; i != NumArgsAsWritten; ++i)
7532 Result.addArgument(readTemplateArgumentLoc());
7538 readTemplateArgumentListInfo(
Result);
7545 if (NumCurrentElementsDeserializing) {
7550 PendingIncompleteDeclChains.push_back(
const_cast<Decl*
>(
D));
7555 assert(isa<TranslationUnitDecl>(
D) &&
"Not a TU?");
7566 if (isa<TranslationUnitDecl, NamespaceDecl, RecordDecl, EnumDecl>(DC)) {
7568 if (!getContext().getLangOpts().
CPlusPlus &&
7569 isa<TranslationUnitDecl>(DC)) {
7573 auto *II = Name.getAsIdentifierInfo();
7574 assert(II &&
"non-identifier name in C?");
7575 if (II->isOutOfDate())
7576 updateOutOfDateIdentifier(*II);
7582 auto *DC = cast<DeclContext>(DCDecl);
7584 FindExternalLexicalDecls(
7590 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(
D))
7591 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7592 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(
D))
7593 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7594 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
7595 if (
auto *Template = FD->getPrimaryTemplate())
7596 Template->LoadLazySpecializations();
7602 RecordLocation
Loc = getLocalBitOffset(Offset);
7603 BitstreamCursor &Cursor =
Loc.F->DeclsCursor;
7605 if (llvm::Error Err = Cursor.JumpToBit(
Loc.Offset)) {
7606 Error(std::move(Err));
7609 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7614 Error(MaybeCode.takeError());
7617 unsigned Code = MaybeCode.get();
7621 if (!MaybeRecCode) {
7622 Error(MaybeRecCode.takeError());
7626 Error(
"malformed AST file: missing C++ ctor initializers");
7630 return Record.readCXXCtorInitializers();
7634 assert(ContextObj &&
"reading base specifiers with no AST context");
7637 RecordLocation
Loc = getLocalBitOffset(Offset);
7638 BitstreamCursor &Cursor =
Loc.F->DeclsCursor;
7640 if (llvm::Error Err = Cursor.JumpToBit(
Loc.Offset)) {
7641 Error(std::move(Err));
7644 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7649 Error(MaybeCode.takeError());
7652 unsigned Code = MaybeCode.get();
7656 if (!MaybeRecCode) {
7657 Error(MaybeCode.takeError());
7660 unsigned RecCode = MaybeRecCode.get();
7663 Error(
"malformed AST file: missing C++ base specifiers");
7667 unsigned NumBases =
Record.readInt();
7670 for (
unsigned I = 0; I != NumBases; ++I)
7671 Bases[I] =
Record.readCXXBaseSpecifier();
7684 ReadModuleOffsetMap(F);
7687 OwningModuleFileIndex == 0
7691 if (OwningModuleFileIndex == 0)
7694 uint64_t NewModuleFileIndex = OwningModuleFile->
Index + 1;
7703 unsigned ModuleFileIndex = ID.getModuleFileIndex();
7704 return M.
Index == ModuleFileIndex - 1;
7712 uint64_t ModuleFileIndex = ID.getModuleFileIndex();
7713 assert(ModuleFileIndex &&
"Untranslated Local Decl?");
7715 return &getModuleManager()[ModuleFileIndex - 1];
7729 if (
Decl *
D = GetExistingDecl(ID))
7733 DeclCursorForID(ID,
Loc);
7793 llvm_unreachable(
"PredefinedDeclIDs unknown enum value");
7796unsigned ASTReader::translateGlobalDeclIDToIndex(
GlobalDeclID GlobalID)
const {
7797 ModuleFile *OwningModuleFile = getOwningModuleFile(GlobalID);
7798 if (!OwningModuleFile) {
7807 assert(ContextObj &&
"reading decl with no AST context");
7816 Merged.push_back(ID);
7821 unsigned Index = translateGlobalDeclIDToIndex(ID);
7823 if (Index >= DeclsLoaded.size()) {
7824 assert(0 &&
"declaration ID out-of-range for AST file");
7825 Error(
"declaration ID out-of-range for AST file");
7829 return DeclsLoaded[Index];
7834 return GetExistingDecl(ID);
7836 unsigned Index = translateGlobalDeclIDToIndex(ID);
7838 if (Index >= DeclsLoaded.size()) {
7839 assert(0 &&
"declaration ID out-of-range for AST file");
7840 Error(
"declaration ID out-of-range for AST file");
7844 if (!DeclsLoaded[Index]) {
7846 if (DeserializationListener)
7847 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7850 return DeclsLoaded[Index];
7859 ReadModuleOffsetMap(M);
7861 ModuleFile *Owner = getOwningModuleFile(GlobalID);
7869 uint64_t OrignalModuleFileIndex = 0;
7872 OrignalModuleFileIndex = I + 1;
7876 if (!OrignalModuleFileIndex)
7884 if (Idx >=
Record.size()) {
7885 Error(
"Corrupted AST file");
7899 ClearSwitchCaseIDs();
7902 RecordLocation
Loc = getLocalBitOffset(Offset);
7903 if (llvm::Error Err =
Loc.F->DeclsCursor.JumpToBit(
Loc.Offset)) {
7904 Error(std::move(Err));
7907 assert(NumCurrentElementsDeserializing == 0 &&
7908 "should not be called while already deserializing");
7910 return ReadStmtFromStream(*
Loc.F);
7919 assert(LexicalDecls.size() % 2 == 0 &&
"expected an even number of entries");
7920 for (
int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7922 if (!IsKindWeWant(K))
7925 auto ID = (
DeclID) + LexicalDecls[I + 1];
7930 if (PredefsVisited[ID])
7933 PredefsVisited[ID] =
true;
7937 assert(
D->
getKind() == K &&
"wrong kind for lexical decl");
7944 if (isa<TranslationUnitDecl>(DC)) {
7945 for (
const auto &Lexical : TULexicalDecls)
7946 Visit(Lexical.first, Lexical.second);
7948 auto I = LexicalDecls.find(DC);
7949 if (I != LexicalDecls.end())
7950 Visit(I->second.first, I->second.second);
7953 ++NumLexicalDeclContextsRead;
7958class UnalignedDeclIDComp {
7964 : Reader(Reader), Mod(M) {}
7992 unsigned Offset,
unsigned Length,
7996 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(
File);
7997 if (I == FileDeclIDs.end())
8000 FileDeclsInfo &DInfo = I->second;
8001 if (DInfo.Decls.empty())
8005 BeginLoc =
SM.getLocForStartOfFile(
File).getLocWithOffset(Offset);
8008 UnalignedDeclIDComp DIDComp(*
this, *DInfo.Mod);
8010 llvm::lower_bound(DInfo.Decls, BeginLoc, DIDComp);
8011 if (BeginIt != DInfo.Decls.begin())
8017 while (BeginIt != DInfo.Decls.begin() &&
8018 GetDecl(getGlobalDeclID(*DInfo.Mod,
8020 ->isTopLevelDeclInObjCContainer())
8024 llvm::upper_bound(DInfo.Decls, EndLoc, DIDComp);
8025 if (EndIt != DInfo.Decls.end())
8030 Decls.push_back(GetDecl(getGlobalDeclID(
8038 "DeclContext has no visible decls in storage");
8042 auto It = Lookups.find(DC);
8043 if (It == Lookups.end())
8053 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
8055 Decls.push_back(ND);
8058 ++NumVisibleDeclContextsRead;
8059 SetExternalVisibleDeclsForName(DC, Name, Decls);
8060 return !Decls.empty();
8067 auto It = Lookups.find(DC);
8068 assert(It != Lookups.end() &&
8069 "have external visible storage but no lookup tables");
8074 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
8078 ++NumVisibleDeclContextsRead;
8080 for (DeclsMap::iterator I = Decls.begin(),
E = Decls.end(); I !=
E; ++I) {
8081 SetExternalVisibleDeclsForName(DC, I->first, I->second);
8083 const_cast<DeclContext *
>(DC)->setHasExternalVisibleStorage(
false);
8088 auto I = Lookups.find(Primary);
8089 return I == Lookups.end() ? nullptr : &I->second;
8098 assert(ImplD && Consumer);
8100 for (
auto *I : ImplD->
methods())
8106void ASTReader::PassInterestingDeclToConsumer(
Decl *
D) {
8114 this->Consumer = Consumer;
8117 PassInterestingDeclsToConsumer();
8119 if (DeserializationListener)
8120 DeserializationListener->ReaderInitialized(
this);
8124 std::fprintf(stderr,
"*** AST File Statistics:\n");
8126 unsigned NumTypesLoaded =
8127 TypesLoaded.size() - llvm::count(TypesLoaded.materialized(),
QualType());
8128 unsigned NumDeclsLoaded =
8129 DeclsLoaded.size() -
8130 llvm::count(DeclsLoaded.materialized(), (
Decl *)
nullptr);
8131 unsigned NumIdentifiersLoaded =
8132 IdentifiersLoaded.size() -
8134 unsigned NumMacrosLoaded =
8135 MacrosLoaded.size() - llvm::count(MacrosLoaded, (
MacroInfo *)
nullptr);
8136 unsigned NumSelectorsLoaded =
8137 SelectorsLoaded.size() - llvm::count(SelectorsLoaded,
Selector());
8139 if (
unsigned TotalNumSLocEntries = getTotalNumSLocs())
8140 std::fprintf(stderr,
" %u/%u source location entries read (%f%%)\n",
8141 NumSLocEntriesRead, TotalNumSLocEntries,
8142 ((
float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
8143 if (!TypesLoaded.empty())
8144 std::fprintf(stderr,
" %u/%u types read (%f%%)\n",
8145 NumTypesLoaded, (
unsigned)TypesLoaded.size(),
8146 ((
float)NumTypesLoaded/TypesLoaded.size() * 100));
8147 if (!DeclsLoaded.empty())
8148 std::fprintf(stderr,
" %u/%u declarations read (%f%%)\n",
8149 NumDeclsLoaded, (
unsigned)DeclsLoaded.size(),
8150 ((
float)NumDeclsLoaded/DeclsLoaded.size() * 100));
8151 if (!IdentifiersLoaded.empty())
8152 std::fprintf(stderr,
" %u/%u identifiers read (%f%%)\n",
8153 NumIdentifiersLoaded, (
unsigned)IdentifiersLoaded.size(),
8154 ((
float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
8155 if (!MacrosLoaded.empty())
8156 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8157 NumMacrosLoaded, (
unsigned)MacrosLoaded.size(),
8158 ((
float)NumMacrosLoaded/MacrosLoaded.size() * 100));
8159 if (!SelectorsLoaded.empty())
8160 std::fprintf(stderr,
" %u/%u selectors read (%f%%)\n",
8161 NumSelectorsLoaded, (
unsigned)SelectorsLoaded.size(),
8162 ((
float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
8163 if (TotalNumStatements)
8164 std::fprintf(stderr,
" %u/%u statements read (%f%%)\n",
8165 NumStatementsRead, TotalNumStatements,
8166 ((
float)NumStatementsRead/TotalNumStatements * 100));
8168 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8169 NumMacrosRead, TotalNumMacros,
8170 ((
float)NumMacrosRead/TotalNumMacros * 100));
8171 if (TotalLexicalDeclContexts)
8172 std::fprintf(stderr,
" %u/%u lexical declcontexts read (%f%%)\n",
8173 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
8174 ((
float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
8176 if (TotalVisibleDeclContexts)
8177 std::fprintf(stderr,
" %u/%u visible declcontexts read (%f%%)\n",
8178 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
8179 ((
float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
8181 if (TotalNumMethodPoolEntries)
8182 std::fprintf(stderr,
" %u/%u method pool entries read (%f%%)\n",
8183 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
8184 ((
float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
8186 if (NumMethodPoolLookups)
8187 std::fprintf(stderr,
" %u/%u method pool lookups succeeded (%f%%)\n",
8188 NumMethodPoolHits, NumMethodPoolLookups,
8189 ((
float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
8190 if (NumMethodPoolTableLookups)
8191 std::fprintf(stderr,
" %u/%u method pool table lookups succeeded (%f%%)\n",
8192 NumMethodPoolTableHits, NumMethodPoolTableLookups,
8193 ((
float)NumMethodPoolTableHits/NumMethodPoolTableLookups
8195 if (NumIdentifierLookupHits)
8196 std::fprintf(stderr,
8197 " %u / %u identifier table lookups succeeded (%f%%)\n",
8198 NumIdentifierLookupHits, NumIdentifierLookups,
8199 (
double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
8202 std::fprintf(stderr,
"\n");
8203 GlobalIndex->printStats();
8206 std::fprintf(stderr,
"\n");
8208 std::fprintf(stderr,
"\n");
8211template<
typename Key,
typename ModuleFile,
unsigned InitialCapacity>
8212LLVM_DUMP_METHOD
static void
8215 InitialCapacity> &Map) {
8216 if (Map.begin() == Map.end())
8221 llvm::errs() << Name <<
":\n";
8222 for (
typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
8224 llvm::errs() <<
" " << (
DeclID)I->first <<
" -> " << I->second->FileName
8229 llvm::errs() <<
"*** PCH/ModuleFile Remappings:\n";
8231 dumpModuleIDMap(
"Global source location entry map", GlobalSLocEntryMap);
8236 GlobalPreprocessedEntityMap);
8238 llvm::errs() <<
"\n*** PCH/Modules Loaded:";
8247 if (llvm::MemoryBuffer *buf = I.Buffer) {
8248 size_t bytes = buf->getBufferSize();
8249 switch (buf->getBufferKind()) {
8250 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
8253 case llvm::MemoryBuffer::MemoryBuffer_MMap:
8269 pushExternalDeclIntoScope(
D,
D->getDeclName());
8271 PreloadedDeclIDs.clear();
8274 if (!FPPragmaOptions.empty()) {
8275 assert(FPPragmaOptions.size() == 1 &&
"Wrong number of FP_PRAGMA_OPTIONS");
8278 SemaObj->CurFPFeatures =
8282 SemaObj->OpenCLFeatures = OpenCLExtensions;
8288 assert(SemaObj &&
"no Sema to update");
8292 if (!SemaDeclRefs.empty()) {
8293 assert(SemaDeclRefs.size() % 3 == 0);
8294 for (
unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
8295 if (!SemaObj->StdNamespace)
8296 SemaObj->StdNamespace = SemaDeclRefs[I].getRawValue();
8297 if (!SemaObj->StdBadAlloc)
8298 SemaObj->StdBadAlloc = SemaDeclRefs[I + 1].getRawValue();
8299 if (!SemaObj->StdAlignValT)
8300 SemaObj->StdAlignValT = SemaDeclRefs[I + 2].getRawValue();
8302 SemaDeclRefs.clear();
8307 if(OptimizeOffPragmaLocation.isValid())
8308 SemaObj->ActOnPragmaOptimize(
false, OptimizeOffPragmaLocation);
8309 if (PragmaMSStructState != -1)
8311 if (PointersToMembersPragmaLocation.isValid()) {
8312 SemaObj->ActOnPragmaMSPointersToMembers(
8314 PragmaMSPointersToMembersState,
8315 PointersToMembersPragmaLocation);
8317 SemaObj->CUDA().ForceHostDeviceDepth = ForceHostDeviceDepth;
8319 if (PragmaAlignPackCurrentValue) {
8323 bool DropFirst =
false;
8324 if (!PragmaAlignPackStack.empty() &&
8325 PragmaAlignPackStack.front().Location.isInvalid()) {
8326 assert(PragmaAlignPackStack.front().Value ==
8327 SemaObj->AlignPackStack.DefaultValue &&
8328 "Expected a default alignment value");
8329 SemaObj->AlignPackStack.Stack.emplace_back(
8330 PragmaAlignPackStack.front().SlotLabel,
8331 SemaObj->AlignPackStack.CurrentValue,
8332 SemaObj->AlignPackStack.CurrentPragmaLocation,
8333 PragmaAlignPackStack.front().PushLocation);
8336 for (
const auto &Entry :
8337 llvm::ArrayRef(PragmaAlignPackStack).drop_front(DropFirst ? 1 : 0)) {
8338 SemaObj->AlignPackStack.Stack.emplace_back(
8339 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8341 if (PragmaAlignPackCurrentLocation.isInvalid()) {
8342 assert(*PragmaAlignPackCurrentValue ==
8343 SemaObj->AlignPackStack.DefaultValue &&
8344 "Expected a default align and pack value");
8347 SemaObj->AlignPackStack.CurrentValue = *PragmaAlignPackCurrentValue;
8348 SemaObj->AlignPackStack.CurrentPragmaLocation =
8349 PragmaAlignPackCurrentLocation;
8352 if (FpPragmaCurrentValue) {
8356 bool DropFirst =
false;
8357 if (!FpPragmaStack.empty() && FpPragmaStack.front().Location.isInvalid()) {
8358 assert(FpPragmaStack.front().Value ==
8359 SemaObj->FpPragmaStack.DefaultValue &&
8360 "Expected a default pragma float_control value");
8361 SemaObj->FpPragmaStack.Stack.emplace_back(
8362 FpPragmaStack.front().SlotLabel, SemaObj->FpPragmaStack.CurrentValue,
8363 SemaObj->FpPragmaStack.CurrentPragmaLocation,
8364 FpPragmaStack.front().PushLocation);
8367 for (
const auto &Entry :
8369 SemaObj->FpPragmaStack.Stack.emplace_back(
8370 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8371 if (FpPragmaCurrentLocation.isInvalid()) {
8372 assert(*FpPragmaCurrentValue == SemaObj->FpPragmaStack.DefaultValue &&
8373 "Expected a default pragma float_control value");
8376 SemaObj->FpPragmaStack.CurrentValue = *FpPragmaCurrentValue;
8377 SemaObj->FpPragmaStack.CurrentPragmaLocation = FpPragmaCurrentLocation;
8382 for (
auto &Import : PendingImportedModulesSema) {
8383 if (Import.ImportLoc.isInvalid())
8385 if (
Module *Imported = getSubmodule(Import.ID)) {
8386 SemaObj->makeModuleVisible(Imported, Import.ImportLoc);
8389 PendingImportedModulesSema.clear();
8396 IdentifierLookupVisitor Visitor(Name, 0,
8397 NumIdentifierLookups,
8398 NumIdentifierLookupHits);
8404 if (PP.getLangOpts().CPlusPlus) {
8405 for (
auto *F : ModuleMgr.pch_modules())
8413 if (!loadGlobalIndex()) {
8414 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
8419 ModuleMgr.visit(Visitor, HitsPtr);
8423 markIdentifierUpToDate(II);
8441 ASTIdentifierLookupTable::key_iterator Current;
8445 ASTIdentifierLookupTable::key_iterator End;
8452 bool SkipModules =
false);
8454 StringRef Next()
override;
8461 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8465 while (Current == End) {
8477 Current = IdTable->key_begin();
8478 End = IdTable->key_end();
8483 StringRef
Result = *Current;
8492 std::unique_ptr<IdentifierIterator> Current;
8493 std::unique_ptr<IdentifierIterator> Queued;
8496 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator>
First,
8497 std::unique_ptr<IdentifierIterator> Second)
8498 : Current(
std::move(
First)), Queued(
std::move(Second)) {}
8500 StringRef Next()
override {
8504 StringRef result = Current->Next();
8505 if (!result.empty())
8510 std::swap(Current, Queued);
8519 std::unique_ptr<IdentifierIterator> ReaderIter(
8521 std::unique_ptr<IdentifierIterator> ModulesIter(
8522 GlobalIndex->createIdentifierIterator());
8523 return new ChainedIdentifierIterator(std::move(ReaderIter),
8524 std::move(ModulesIter));
8531namespace serialization {
8536 unsigned PriorGeneration;
8537 unsigned InstanceBits = 0;
8538 unsigned FactoryBits = 0;
8539 bool InstanceHasMoreThanOneDecl =
false;
8540 bool FactoryHasMoreThanOneDecl =
false;
8546 unsigned PriorGeneration)
8547 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8557 ++Reader.NumMethodPoolTableLookups;
8560 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8561 if (Pos == PoolTable->end())
8564 ++Reader.NumMethodPoolTableHits;
8565 ++Reader.NumSelectorsRead;
8569 ++Reader.NumMethodPoolEntriesRead;
8571 if (Reader.DeserializationListener)
8577 InstanceMethods.append(
Data.Instance.rbegin(),
Data.Instance.rend());
8578 FactoryMethods.append(
Data.Factory.rbegin(),
Data.Factory.rend());
8579 InstanceBits =
Data.InstanceBits;
8580 FactoryBits =
Data.FactoryBits;
8581 InstanceHasMoreThanOneDecl =
Data.InstanceHasMoreThanOneDecl;
8582 FactoryHasMoreThanOneDecl =
Data.FactoryHasMoreThanOneDecl;
8588 return InstanceMethods;
8593 return FactoryMethods;
8600 return InstanceHasMoreThanOneDecl;
8618 unsigned &Generation = SelectorGeneration[Sel];
8619 unsigned PriorGeneration = Generation;
8621 SelectorOutOfDate[Sel] =
false;
8624 ++NumMethodPoolLookups;
8626 ModuleMgr.
visit(Visitor);
8632 ++NumMethodPoolHits;
8657 if (SelectorOutOfDate[Sel])
8665 for (
unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8667 = dyn_cast_or_null<NamespaceDecl>(
GetDecl(KnownNamespaces[I])))
8668 Namespaces.push_back(Namespace);
8673 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8674 for (
unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8675 UndefinedButUsedDecl &
U = UndefinedButUsed[Idx++];
8678 Undefined.insert(std::make_pair(
D,
Loc));
8680 UndefinedButUsed.clear();
8686 for (
unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8689 uint64_t Count = DelayedDeleteExprs[Idx++];
8690 for (uint64_t
C = 0;
C < Count; ++
C) {
8693 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8694 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8701 for (
unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8702 VarDecl *Var = dyn_cast_or_null<VarDecl>(
GetDecl(TentativeDefinitions[I]));
8704 TentativeDefs.push_back(Var);
8706 TentativeDefinitions.clear();
8711 for (
unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8713 = dyn_cast_or_null<DeclaratorDecl>(
GetDecl(UnusedFileScopedDecls[I]));
8717 UnusedFileScopedDecls.clear();
8722 for (
unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8724 = dyn_cast_or_null<CXXConstructorDecl>(
GetDecl(DelegatingCtorDecls[I]));
8728 DelegatingCtorDecls.clear();
8732 for (
unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8734 = dyn_cast_or_null<TypedefNameDecl>(
GetDecl(ExtVectorDecls[I]));
8738 ExtVectorDecls.clear();
8743 for (
unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8746 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8750 UnusedLocalTypedefNameCandidates.clear();
8755 for (
auto I : DeclsToCheckForDeferredDiags) {
8756 auto *
D = dyn_cast_or_null<Decl>(
GetDecl(I));
8760 DeclsToCheckForDeferredDiags.clear();
8765 if (ReferencedSelectorsData.empty())
8770 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8772 while (I < DataSize) {
8776 Sels.push_back(std::make_pair(Sel, SelLoc));
8778 ReferencedSelectorsData.clear();
8783 if (WeakUndeclaredIdentifiers.empty())
8786 for (
unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; ) {
8794 WeakIDs.push_back(std::make_pair(WeakId, WI));
8796 WeakUndeclaredIdentifiers.clear();
8800 for (
unsigned Idx = 0, N = VTableUses.size(); Idx < N; ) {
8802 VTableUse &TableInfo = VTableUses[Idx++];
8803 VT.
Record = dyn_cast_or_null<CXXRecordDecl>(
GetDecl(TableInfo.ID));
8806 VTables.push_back(VT);
8814 for (
unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8815 PendingInstantiation &Inst = PendingInstantiations[Idx++];
8819 Pending.push_back(std::make_pair(
D,
Loc));
8821 PendingInstantiations.clear();
8825 llvm::MapVector<
const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8827 for (
auto &LPT : LateParsedTemplates) {
8830 for (
unsigned Idx = 0, N = LateParsed.size(); Idx < N;
8832 FunctionDecl *FD = ReadDeclAs<FunctionDecl>(*FMod, LateParsed, Idx);
8834 auto LT = std::make_unique<LateParsedTemplate>();
8839 assert(F &&
"No module");
8841 unsigned TokN = LateParsed[Idx++];
8842 LT->Toks.reserve(TokN);
8843 for (
unsigned T = 0;
T < TokN; ++
T)
8844 LT->Toks.push_back(
ReadToken(*F, LateParsed, Idx));
8846 LPTMap.insert(std::make_pair(FD, std::move(
LT)));
8850 LateParsedTemplates.clear();
8857 LambdaDeclarationsForMerging.insert(
8870 assert(ID &&
"Non-zero identifier ID required");
8871 unsigned Index = translateIdentifierIDToIndex(ID).second;
8872 assert(Index < IdentifiersLoaded.size() &&
"identifier ID out of range");
8873 IdentifiersLoaded[Index] = II;
8874 if (DeserializationListener)
8897 if (NumCurrentElementsDeserializing && !Decls) {
8898 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8902 for (
unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8915 Decls->push_back(
D);
8922 pushExternalDeclIntoScope(
D, II);
8926std::pair<ModuleFile *, unsigned>
8927ASTReader::translateIdentifierIDToIndex(
IdentifierID ID)
const {
8929 return {
nullptr, 0};
8931 unsigned ModuleFileIndex = ID >> 32;
8932 unsigned LocalID = ID & llvm::maskTrailingOnes<IdentifierID>(32);
8934 assert(ModuleFileIndex &&
"not translating loaded IdentifierID?");
8946 if (IdentifiersLoaded.empty()) {
8947 Error(
"no identifier table in AST file");
8951 auto [M, Index] = translateIdentifierIDToIndex(ID);
8952 if (!IdentifiersLoaded[Index]) {
8953 assert(M !=
nullptr &&
"Untranslated Identifier ID?");
8956 const unsigned char *
Data =
8963 IdentifiersLoaded[Index] = &II;
8965 if (DeserializationListener)
8969 return IdentifiersLoaded[Index];
8981 ReadModuleOffsetMap(M);
8983 unsigned ModuleFileIndex = LocalID >> 32;
8984 LocalID &= llvm::maskTrailingOnes<IdentifierID>(32);
8987 assert(MF &&
"malformed identifier ID encoding?");
8989 if (!ModuleFileIndex)
8999 if (MacrosLoaded.empty()) {
9000 Error(
"no macro table in AST file");
9005 if (!MacrosLoaded[ID]) {
9008 assert(I != GlobalMacroMap.
end() &&
"Corrupted global macro map");
9014 if (DeserializationListener)
9019 return MacrosLoaded[ID];
9027 ReadModuleOffsetMap(M);
9031 assert(I != M.
MacroRemap.
end() &&
"Invalid index into macro index remap");
9033 return LocalID + I->second;
9042 ReadModuleOffsetMap(M);
9047 &&
"Invalid index into submodule index remap");
9049 return LocalID + I->second;
9054 assert(GlobalID == 0 &&
"Unhandled global submodule ID");
9058 if (GlobalID > SubmodulesLoaded.size()) {
9059 Error(
"submodule ID out of range in AST file");
9074 return I == GlobalSubmoduleMap.
end() ? nullptr : I->second;
9077 unsigned IndexFromEnd = ID >> 1;
9078 assert(IndexFromEnd &&
"got reference to unknown module file");
9095 auto I = llvm::find(PCHModules, M);
9096 assert(I != PCHModules.end() &&
"emitting reference to unknown file");
9097 return (I - PCHModules.end()) << 1;
9107 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
9112 llvm::sys::path::parent_path(MF.
FileName),
9115 return std::nullopt;
9119 auto I = DefinitionSource.find(FD);
9120 if (I == DefinitionSource.end())
9133 if (ID > SelectorsLoaded.size()) {
9134 Error(
"selector ID out of range in AST file");
9138 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() ==
nullptr) {
9141 assert(I != GlobalSelectorMap.
end() &&
"Corrupted global selector map");
9145 SelectorsLoaded[ID - 1] =
9147 if (DeserializationListener)
9148 DeserializationListener->
SelectorRead(ID, SelectorsLoaded[ID - 1]);
9151 return SelectorsLoaded[ID - 1];
9169 ReadModuleOffsetMap(M);
9174 &&
"Invalid index into selector index remap");
9176 return LocalID + I->second;
9181 switch (Name.getNameKind()) {
9207 NameInfo.
setName(readDeclarationName());
9219 unsigned NumTPLists =
readInt();
9224 for (
unsigned i = 0; i != NumTPLists; ++i)
9235 unsigned NumParams =
readInt();
9237 Params.reserve(NumParams);
9239 Params.push_back(readDeclAs<NamedDecl>());
9241 bool HasRequiresClause =
readBool();
9242 Expr *RequiresClause = HasRequiresClause ?
readExpr() :
nullptr;
9245 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
9246 return TemplateParams;
9251 bool Canonicalize) {
9252 unsigned NumTemplateArgs =
readInt();
9253 TemplArgs.reserve(NumTemplateArgs);
9254 while (NumTemplateArgs--)
9260 unsigned NumDecls =
readInt();
9262 while (NumDecls--) {
9274 bool inheritConstructors =
readBool();
9280 Result.setInheritConstructors(inheritConstructors);
9287 unsigned NumInitializers =
readInt();
9288 assert(NumInitializers &&
"wrote ctor initializers but have no inits");
9290 for (
unsigned i = 0; i != NumInitializers; ++i) {
9292 bool IsBaseVirtual =
false;
9308 Member = readDeclAs<FieldDecl>();
9312 IndirectMember = readDeclAs<IndirectFieldDecl>();
9323 BOMInit =
new (Context)
9325 RParenLoc, MemberOrEllipsisLoc);
9327 BOMInit =
new (Context)
9330 BOMInit =
new (Context)
9334 BOMInit =
new (Context)
9336 LParenLoc,
Init, RParenLoc);
9339 unsigned SourceOrder =
readInt();
9343 CtorInitializers[i] = BOMInit;
9346 return CtorInitializers;
9354 for (
unsigned I = 0; I != N; ++I) {
9355 auto Kind = readNestedNameSpecifierKind();
9387 Builder.Extend(Context,
9389 T->getTypeLoc(), ColonColonLoc);
9395 Builder.MakeGlobal(Context, ColonColonLoc);
9408 return Builder.getWithLocInContext(Context);
9419 const StringRef Blob) {
9420 unsigned Count =
Record[0];
9421 const char *Byte = Blob.data();
9422 llvm::BitVector Ret = llvm::BitVector(Count,
false);
9423 for (
unsigned I = 0; I < Count; ++Byte)
9424 for (
unsigned Bit = 0; Bit < 8 && I < Count; ++Bit, ++I)
9425 if (*Byte & (1 << Bit))
9437 unsigned Len =
Record[Idx++];
9453 if (!BaseDirectory.empty())
9460 unsigned Major =
Record[Idx++];
9461 unsigned Minor =
Record[Idx++];
9462 unsigned Subminor =
Record[Idx++];
9464 return VersionTuple(Major);
9466 return VersionTuple(Major, Minor - 1);
9467 return VersionTuple(Major, Minor - 1, Subminor - 1);
9478 return Diag(CurrentImportLoc, DiagID);
9492 if (WarnedStackExhausted)
9494 WarnedStackExhausted =
true;
9496 Diag(
Loc, diag::warn_stack_exhausted);
9508 assert((*CurrSwitchCaseStmts)[ID] ==
nullptr &&
9509 "Already have a SwitchCase with this ID");
9510 (*CurrSwitchCaseStmts)[ID] = SC;
9515 assert((*CurrSwitchCaseStmts)[ID] !=
nullptr &&
"No SwitchCase with this ID");
9516 return (*CurrSwitchCaseStmts)[ID];
9520 CurrSwitchCaseStmts->clear();
9525 std::vector<RawComment *> Comments;
9532 BitstreamCursor &Cursor = I->first;
9539 Cursor.advanceSkippingSubblocks(
9540 BitstreamCursor::AF_DontPopBlockAtEnd);
9542 Error(MaybeEntry.takeError());
9545 llvm::BitstreamEntry Entry = MaybeEntry.get();
9547 switch (Entry.Kind) {
9548 case llvm::BitstreamEntry::SubBlock:
9549 case llvm::BitstreamEntry::Error:
9550 Error(
"malformed block record in AST file");
9552 case llvm::BitstreamEntry::EndBlock:
9554 case llvm::BitstreamEntry::Record:
9562 if (!MaybeComment) {
9563 Error(MaybeComment.takeError());
9572 bool IsTrailingComment =
Record[Idx++];
9573 bool IsAlmostTrailingComment =
Record[Idx++];
9575 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9581 llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
9582 FileToOffsetToComment;
9586 std::pair<FileID, unsigned>
Loc =
9602 assert(NumUserInputs <= NumInputs);
9603 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9604 for (
unsigned I = 0; I < N; ++I) {
9605 bool IsSystem = I >= NumUserInputs;
9607 Visitor(IFI, IsSystem);
9612 bool IncludeSystem,
bool Complain,
9614 bool isSystem)> Visitor) {
9617 assert(NumUserInputs <= NumInputs);
9618 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9619 for (
unsigned I = 0; I < N; ++I) {
9620 bool IsSystem = I >= NumUserInputs;
9621 InputFile IF = getInputFile(MF, I+1, Complain);
9622 Visitor(IF, IsSystem);
9630 for (
unsigned I = 0; I < NumInputs; ++I) {
9633 if (
auto FE = getInputFile(MF, I + 1).getFile())
9638void ASTReader::finishPendingActions() {
9640 !PendingIdentifierInfos.empty() || !PendingDeducedFunctionTypes.empty() ||
9641 !PendingDeducedVarTypes.empty() || !PendingIncompleteDeclChains.empty() ||
9642 !PendingDeclChains.empty() || !PendingMacroIDs.empty() ||
9643 !PendingDeclContextInfos.empty() || !PendingUpdateRecords.empty() ||
9644 !PendingObjCExtensionIvarRedeclarations.empty()) {
9647 using TopLevelDeclsMap =
9648 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9649 TopLevelDeclsMap TopLevelDecls;
9651 while (!PendingIdentifierInfos.empty()) {
9654 std::move(PendingIdentifierInfos.back().second);
9655 PendingIdentifierInfos.pop_back();
9662 for (
unsigned I = 0; I != PendingDeducedFunctionTypes.size(); ++I) {
9663 auto *FD = PendingDeducedFunctionTypes[I].first;
9664 FD->setType(
GetType(PendingDeducedFunctionTypes[I].second));
9666 if (
auto *DT = FD->getReturnType()->getContainedDeducedType()) {
9669 if (DT->isDeduced()) {
9670 PendingDeducedTypeUpdates.insert(
9671 {FD->getCanonicalDecl(), FD->getReturnType()});
9678 PendingUndeducedFunctionDecls.push_back(FD);
9682 PendingDeducedFunctionTypes.clear();
9686 for (
unsigned I = 0; I != PendingDeducedVarTypes.size(); ++I) {
9687 auto *VD = PendingDeducedVarTypes[I].first;
9688 VD->setType(
GetType(PendingDeducedVarTypes[I].second));
9690 PendingDeducedVarTypes.clear();
9694 for (
unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9695 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9697 PendingIncompleteDeclChains.clear();
9700 for (
unsigned I = 0; I != PendingDeclChains.size(); ++I)
9701 loadPendingDeclChain(PendingDeclChains[I].first,
9702 PendingDeclChains[I].second);
9703 PendingDeclChains.clear();
9706 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9707 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9709 for (
unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9710 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9715 for (
unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9718 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9720 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9722 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9723 if (!Info.M->isModule())
9727 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9729 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9730 if (Info.M->isModule())
9734 PendingMacroIDs.clear();
9738 while (!PendingDeclContextInfos.empty()) {
9739 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9740 PendingDeclContextInfos.pop_front();
9743 Info.D->setDeclContextsImpl(SemaDC, LexicalDC,
getContext());
9747 while (!PendingUpdateRecords.empty()) {
9748 auto Update = PendingUpdateRecords.pop_back_val();
9749 ReadingKindTracker ReadingKind(Read_Decl, *
this);
9750 loadDeclUpdateRecords(
Update);
9753 while (!PendingObjCExtensionIvarRedeclarations.empty()) {
9754 auto ExtensionsPair = PendingObjCExtensionIvarRedeclarations.back().first;
9755 auto DuplicateIvars =
9756 PendingObjCExtensionIvarRedeclarations.back().second;
9759 ExtensionsPair.first->getASTContext(),
9760 ExtensionsPair.second->getASTContext(), NonEquivalentDecls,
9764 if (Ctx.IsEquivalent(ExtensionsPair.first, ExtensionsPair.second)) {
9766 for (
auto IvarPair : DuplicateIvars) {
9767 ObjCIvarDecl *Ivar = IvarPair.first, *PrevIvar = IvarPair.second;
9769 Ivar->setDeclContextsImpl(PrevIvar->getDeclContext(),
9775 ExtensionsPair.first->setInvalidDecl();
9776 ExtensionsPair.second->getClassInterface()
9778 ->setIvarList(
nullptr);
9780 for (
auto IvarPair : DuplicateIvars) {
9781 Diag(IvarPair.first->getLocation(),
9782 diag::err_duplicate_ivar_declaration)
9783 << IvarPair.first->getIdentifier();
9784 Diag(IvarPair.second->getLocation(), diag::note_previous_definition);
9787 PendingObjCExtensionIvarRedeclarations.pop_back();
9793 assert(PendingFakeDefinitionData.empty() &&
9794 "faked up a class definition but never saw the real one");
9800 for (
Decl *
D : PendingDefinitions) {
9801 if (
TagDecl *TD = dyn_cast<TagDecl>(
D)) {
9802 if (
const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9807 if (
auto RD = dyn_cast<CXXRecordDecl>(
D)) {
9808 for (
auto *R = getMostRecentExistingDecl(RD); R;
9811 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9812 "declaration thinks it's the definition but it isn't");
9813 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9820 if (
auto ID = dyn_cast<ObjCInterfaceDecl>(
D)) {
9825 for (
auto *R = getMostRecentExistingDecl(ID); R; R = R->
getPreviousDecl())
9826 cast<ObjCInterfaceDecl>(R)->Data =
ID->Data;
9831 if (
auto PD = dyn_cast<ObjCProtocolDecl>(
D)) {
9832 for (
auto *R = getMostRecentExistingDecl(PD); R; R = R->
getPreviousDecl())
9833 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9838 auto RTD = cast<RedeclarableTemplateDecl>(
D)->getCanonicalDecl();
9839 for (
auto *R = getMostRecentExistingDecl(RTD); R; R = R->
getPreviousDecl())
9840 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9842 PendingDefinitions.clear();
9848 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9849 PBEnd = PendingBodies.end();
9850 PB != PBEnd; ++PB) {
9851 if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9861 if (
auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9862 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9867 if (!
getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9873 if (!FD->isLateTemplateParsed() &&
9874 !NonConstDefn->isLateTemplateParsed() &&
9879 FD->getODRHash() != NonConstDefn->getODRHash()) {
9880 if (!isa<CXXMethodDecl>(FD)) {
9881 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9882 }
else if (FD->getLexicalParent()->isFileContext() &&
9883 NonConstDefn->getLexicalParent()->isFileContext()) {
9887 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9898 PendingBodies.clear();
9901 for (
auto [RD, MD] : PendingAddedClassMembers) {
9902 RD->addedMember(MD);
9904 PendingAddedClassMembers.clear();
9907 for (
auto *ND : PendingMergedDefinitionsToDeduplicate)
9909 PendingMergedDefinitionsToDeduplicate.clear();
9912void ASTReader::diagnoseOdrViolations() {
9913 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9914 PendingRecordOdrMergeFailures.empty() &&
9915 PendingFunctionOdrMergeFailures.empty() &&
9916 PendingEnumOdrMergeFailures.empty() &&
9917 PendingObjCInterfaceOdrMergeFailures.empty() &&
9918 PendingObjCProtocolOdrMergeFailures.empty())
9925 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9926 PendingOdrMergeFailures.clear();
9927 for (
auto &Merge : OdrMergeFailures) {
9928 Merge.first->buildLookup();
9929 Merge.first->decls_begin();
9930 Merge.first->bases_begin();
9931 Merge.first->vbases_begin();
9932 for (
auto &RecordPair : Merge.second) {
9933 auto *RD = RecordPair.first;
9941 auto RecordOdrMergeFailures = std::move(PendingRecordOdrMergeFailures);
9942 PendingRecordOdrMergeFailures.clear();
9943 for (
auto &Merge : RecordOdrMergeFailures) {
9944 Merge.first->decls_begin();
9945 for (
auto &
D : Merge.second)
9950 auto ObjCInterfaceOdrMergeFailures =
9951 std::move(PendingObjCInterfaceOdrMergeFailures);
9952 PendingObjCInterfaceOdrMergeFailures.clear();
9953 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
9954 Merge.first->decls_begin();
9955 for (
auto &InterfacePair : Merge.second)
9956 InterfacePair.first->decls_begin();
9960 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9961 PendingFunctionOdrMergeFailures.clear();
9962 for (
auto &Merge : FunctionOdrMergeFailures) {
9963 Merge.first->buildLookup();
9964 Merge.first->decls_begin();
9965 Merge.first->getBody();
9966 for (
auto &FD : Merge.second) {
9974 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9975 PendingEnumOdrMergeFailures.clear();
9976 for (
auto &Merge : EnumOdrMergeFailures) {
9977 Merge.first->decls_begin();
9978 for (
auto &
Enum : Merge.second) {
9979 Enum->decls_begin();
9984 auto ObjCProtocolOdrMergeFailures =
9985 std::move(PendingObjCProtocolOdrMergeFailures);
9986 PendingObjCProtocolOdrMergeFailures.clear();
9987 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
9988 Merge.first->decls_begin();
9989 for (
auto &ProtocolPair : Merge.second)
9990 ProtocolPair.first->decls_begin();
9999 while (!PendingOdrMergeChecks.empty()) {
10000 NamedDecl *
D = PendingOdrMergeChecks.pop_back_val();
10011 bool Found =
false;
10015 if (RI->getLexicalDeclContext() == CanonDef) {
10030 for (
auto *CanonMember : CanonDef->
decls()) {
10031 if (CanonMember->getCanonicalDecl() == DCanon) {
10040 if (
auto *ND = dyn_cast<NamedDecl>(CanonMember))
10041 if (ND->getDeclName() ==
D->getDeclName())
10042 Candidates.push_back(ND);
10048 if (!isa<TagDecl>(
D))
10053 Deserializing RecursionGuard(
this);
10055 std::string CanonDefModule =
10057 cast<Decl>(CanonDef));
10060 << CanonDef << CanonDefModule.empty() << CanonDefModule;
10062 if (Candidates.empty())
10063 Diag(cast<Decl>(CanonDef)->getLocation(),
10064 diag::note_module_odr_violation_no_possible_decls) <<
D;
10066 for (
unsigned I = 0, N = Candidates.size(); I != N; ++I)
10067 Diag(Candidates[I]->getLocation(),
10068 diag::note_module_odr_violation_possible_decl)
10072 DiagnosedOdrMergeFailures.insert(CanonDef);
10076 if (OdrMergeFailures.empty() && RecordOdrMergeFailures.empty() &&
10077 FunctionOdrMergeFailures.empty() && EnumOdrMergeFailures.empty() &&
10078 ObjCInterfaceOdrMergeFailures.empty() &&
10079 ObjCProtocolOdrMergeFailures.empty())
10086 for (
auto &Merge : OdrMergeFailures) {
10089 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10092 bool Diagnosed =
false;
10094 for (
auto &RecordPair : Merge.second) {
10095 if (DiagsEmitter.diagnoseMismatch(FirstRecord, RecordPair.first,
10096 RecordPair.second)) {
10109 Diag(Merge.first->getLocation(),
10110 diag::err_module_odr_violation_different_instantiations)
10117 for (
auto &Merge : RecordOdrMergeFailures) {
10120 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10124 bool Diagnosed =
false;
10125 for (
auto *SecondRecord : Merge.second) {
10126 if (DiagsEmitter.diagnoseMismatch(FirstRecord, SecondRecord)) {
10132 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10136 for (
auto &Merge : FunctionOdrMergeFailures) {
10138 bool Diagnosed =
false;
10139 for (
auto &SecondFunction : Merge.second) {
10140 if (DiagsEmitter.diagnoseMismatch(FirstFunction, SecondFunction)) {
10146 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10150 for (
auto &Merge : EnumOdrMergeFailures) {
10153 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10156 EnumDecl *FirstEnum = Merge.first;
10157 bool Diagnosed =
false;
10158 for (
auto &SecondEnum : Merge.second) {
10159 if (DiagsEmitter.diagnoseMismatch(FirstEnum, SecondEnum)) {
10165 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10168 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
10171 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10174 bool Diagnosed =
false;
10176 for (
auto &InterfacePair : Merge.second) {
10177 if (DiagsEmitter.diagnoseMismatch(FirstID, InterfacePair.first,
10178 InterfacePair.second)) {
10184 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10187 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
10190 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10194 bool Diagnosed =
false;
10195 for (
auto &ProtocolPair : Merge.second) {
10196 if (DiagsEmitter.diagnoseMismatch(FirstProtocol, ProtocolPair.first,
10197 ProtocolPair.second)) {
10203 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10208 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
10209 ReadTimer->startTimer();
10213 assert(NumCurrentElementsDeserializing &&
10214 "FinishedDeserializing not paired with StartedDeserializing");
10215 if (NumCurrentElementsDeserializing == 1) {
10218 finishPendingActions();
10220 --NumCurrentElementsDeserializing;
10222 if (NumCurrentElementsDeserializing == 0) {
10228 while (!PendingExceptionSpecUpdates.empty() ||
10229 !PendingDeducedTypeUpdates.empty()) {
10230 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
10231 PendingExceptionSpecUpdates.clear();
10232 for (
auto Update : ESUpdates) {
10233 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10237 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(
Update.second));
10238 for (
auto *Redecl :
Update.second->redecls())
10242 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
10243 PendingDeducedTypeUpdates.clear();
10244 for (
auto Update : DTUpdates) {
10245 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10251 auto UDTUpdates = std::move(PendingUndeducedFunctionDecls);
10252 PendingUndeducedFunctionDecls.clear();
10256 (void)UndeducedFD->getMostRecentDecl();
10260 ReadTimer->stopTimer();
10262 diagnoseOdrViolations();
10267 PassInterestingDeclsToConsumer();
10274 auto It = PendingFakeLookupResults.find(II);
10275 if (It != PendingFakeLookupResults.end()) {
10276 for (
auto *ND : It->second)
10281 It->second.clear();
10287 }
else if (SemaObj->
TUScope) {
10299 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
10300 StringRef isysroot,
10302 bool AllowASTWithCompilerErrors,
10303 bool AllowConfigurationMismatch,
bool ValidateSystemInputs,
10304 bool ValidateASTInputFilesContent,
bool UseGlobalIndex,
10305 std::unique_ptr<llvm::Timer> ReadTimer)
10309 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
10310 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
10311 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
10312 PCHContainerRdr, PP.getHeaderSearchInfo()),
10313 DummyIdResolver(PP), ReadTimer(
std::move(ReadTimer)), isysroot(isysroot),
10314 DisableValidationKind(DisableValidationKind),
10315 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
10316 AllowConfigurationMismatch(AllowConfigurationMismatch),
10317 ValidateSystemInputs(ValidateSystemInputs),
10318 ValidateASTInputFilesContent(ValidateASTInputFilesContent),
10319 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
10322 for (
const auto &Ext : Extensions) {
10323 auto BlockName = Ext->getExtensionMetadata().BlockName;
10324 auto Known = ModuleFileExtensions.find(BlockName);
10325 if (Known != ModuleFileExtensions.end()) {
10326 Diags.
Report(diag::warn_duplicate_module_file_extension)
10331 ModuleFileExtensions.insert({BlockName, Ext});
10336 if (OwnsDeserializationListener)
10337 delete DeserializationListener;
10341 return SemaObj ? SemaObj->
IdResolver : DummyIdResolver;
10345 unsigned AbbrevID) {
10348 return Cursor.readRecord(AbbrevID,
Record);
10365#define GEN_CLANG_CLAUSE_CLASS
10366#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
10367#include "llvm/Frontend/OpenMP/OMP.inc"
10381 switch (llvm::omp::Clause(
Record.readInt())) {
10382 case llvm::omp::OMPC_if:
10385 case llvm::omp::OMPC_final:
10388 case llvm::omp::OMPC_num_threads:
10391 case llvm::omp::OMPC_safelen:
10394 case llvm::omp::OMPC_simdlen:
10397 case llvm::omp::OMPC_sizes: {
10398 unsigned NumSizes =
Record.readInt();
10402 case llvm::omp::OMPC_full:
10405 case llvm::omp::OMPC_partial:
10408 case llvm::omp::OMPC_allocator:
10411 case llvm::omp::OMPC_collapse:
10414 case llvm::omp::OMPC_default:
10417 case llvm::omp::OMPC_proc_bind:
10420 case llvm::omp::OMPC_schedule:
10423 case llvm::omp::OMPC_ordered:
10426 case llvm::omp::OMPC_nowait:
10429 case llvm::omp::OMPC_untied:
10432 case llvm::omp::OMPC_mergeable:
10435 case llvm::omp::OMPC_read:
10438 case llvm::omp::OMPC_write:
10441 case llvm::omp::OMPC_update:
10444 case llvm::omp::OMPC_capture:
10447 case llvm::omp::OMPC_compare:
10450 case llvm::omp::OMPC_fail:
10453 case llvm::omp::OMPC_seq_cst:
10456 case llvm::omp::OMPC_acq_rel:
10459 case llvm::omp::OMPC_acquire:
10462 case llvm::omp::OMPC_release:
10465 case llvm::omp::OMPC_relaxed:
10468 case llvm::omp::OMPC_weak:
10471 case llvm::omp::OMPC_threads:
10474 case llvm::omp::OMPC_simd:
10477 case llvm::omp::OMPC_nogroup:
10480 case llvm::omp::OMPC_unified_address:
10483 case llvm::omp::OMPC_unified_shared_memory:
10486 case llvm::omp::OMPC_reverse_offload:
10489 case llvm::omp::OMPC_dynamic_allocators:
10492 case llvm::omp::OMPC_atomic_default_mem_order:
10495 case llvm::omp::OMPC_at:
10498 case llvm::omp::OMPC_severity:
10501 case llvm::omp::OMPC_message:
10504 case llvm::omp::OMPC_private:
10507 case llvm::omp::OMPC_firstprivate:
10510 case llvm::omp::OMPC_lastprivate:
10513 case llvm::omp::OMPC_shared:
10516 case llvm::omp::OMPC_reduction: {
10517 unsigned N =
Record.readInt();
10522 case llvm::omp::OMPC_task_reduction:
10525 case llvm::omp::OMPC_in_reduction:
10528 case llvm::omp::OMPC_linear:
10531 case llvm::omp::OMPC_aligned:
10534 case llvm::omp::OMPC_copyin:
10537 case llvm::omp::OMPC_copyprivate:
10540 case llvm::omp::OMPC_flush:
10543 case llvm::omp::OMPC_depobj:
10546 case llvm::omp::OMPC_depend: {
10547 unsigned NumVars =
Record.readInt();
10548 unsigned NumLoops =
Record.readInt();
10552 case llvm::omp::OMPC_device:
10555 case llvm::omp::OMPC_map: {
10564 case llvm::omp::OMPC_num_teams:
10567 case llvm::omp::OMPC_thread_limit:
10570 case llvm::omp::OMPC_priority:
10573 case llvm::omp::OMPC_grainsize:
10576 case llvm::omp::OMPC_num_tasks:
10579 case llvm::omp::OMPC_hint:
10582 case llvm::omp::OMPC_dist_schedule:
10585 case llvm::omp::OMPC_defaultmap:
10588 case llvm::omp::OMPC_to: {
10597 case llvm::omp::OMPC_from: {
10606 case llvm::omp::OMPC_use_device_ptr: {
10615 case llvm::omp::OMPC_use_device_addr: {
10624 case llvm::omp::OMPC_is_device_ptr: {
10633 case llvm::omp::OMPC_has_device_addr: {
10642 case llvm::omp::OMPC_allocate:
10645 case llvm::omp::OMPC_nontemporal:
10648 case llvm::omp::OMPC_inclusive:
10651 case llvm::omp::OMPC_exclusive:
10654 case llvm::omp::OMPC_order:
10657 case llvm::omp::OMPC_init:
10660 case llvm::omp::OMPC_use:
10663 case llvm::omp::OMPC_destroy:
10666 case llvm::omp::OMPC_novariants:
10669 case llvm::omp::OMPC_nocontext:
10672 case llvm::omp::OMPC_detach:
10675 case llvm::omp::OMPC_uses_allocators:
10678 case llvm::omp::OMPC_affinity:
10681 case llvm::omp::OMPC_filter:
10684 case llvm::omp::OMPC_bind:
10687 case llvm::omp::OMPC_align:
10690 case llvm::omp::OMPC_ompx_dyn_cgroup_mem:
10693 case llvm::omp::OMPC_doacross: {
10694 unsigned NumVars =
Record.readInt();
10695 unsigned NumLoops =
Record.readInt();
10699 case llvm::omp::OMPC_ompx_attribute:
10702 case llvm::omp::OMPC_ompx_bare:
10705#define OMP_CLAUSE_NO_CLASS(Enum, Str) \
10706 case llvm::omp::Enum: \
10708#include "llvm/Frontend/OpenMP/OMPKinds.def"
10712 assert(
C &&
"Unknown OMPClause type");
10715 C->setLocStart(
Record.readSourceLocation());
10716 C->setLocEnd(
Record.readSourceLocation());
10722 C->setPreInitStmt(
Record.readSubStmt(),
10728 C->setPostUpdateExpr(
Record.readSubExpr());
10731void OMPClauseReader::VisitOMPIfClause(
OMPIfClause *
C) {
10734 C->setNameModifierLoc(
Record.readSourceLocation());
10735 C->setColonLoc(
Record.readSourceLocation());
10736 C->setCondition(
Record.readSubExpr());
10737 C->setLParenLoc(
Record.readSourceLocation());
10742 C->setCondition(
Record.readSubExpr());
10743 C->setLParenLoc(
Record.readSourceLocation());
10748 C->setNumThreads(
Record.readSubExpr());
10749 C->setLParenLoc(
Record.readSourceLocation());
10753 C->setSafelen(
Record.readSubExpr());
10754 C->setLParenLoc(
Record.readSourceLocation());
10758 C->setSimdlen(
Record.readSubExpr());
10759 C->setLParenLoc(
Record.readSourceLocation());
10763 for (
Expr *&
E :
C->getSizesRefs())
10765 C->setLParenLoc(
Record.readSourceLocation());
10771 C->setFactor(
Record.readSubExpr());
10772 C->setLParenLoc(
Record.readSourceLocation());
10776 C->setAllocator(
Record.readExpr());
10777 C->setLParenLoc(
Record.readSourceLocation());
10781 C->setNumForLoops(
Record.readSubExpr());
10782 C->setLParenLoc(
Record.readSourceLocation());
10786 C->setDefaultKind(
static_cast<llvm::omp::DefaultKind
>(
Record.readInt()));
10787 C->setLParenLoc(
Record.readSourceLocation());
10788 C->setDefaultKindKwLoc(
Record.readSourceLocation());
10792 C->setProcBindKind(
static_cast<llvm::omp::ProcBindKind
>(
Record.readInt()));
10793 C->setLParenLoc(
Record.readSourceLocation());
10794 C->setProcBindKindKwLoc(
Record.readSourceLocation());
10799 C->setScheduleKind(
10801 C->setFirstScheduleModifier(
10803 C->setSecondScheduleModifier(
10805 C->setChunkSize(
Record.readSubExpr());
10806 C->setLParenLoc(
Record.readSourceLocation());
10807 C->setFirstScheduleModifierLoc(
Record.readSourceLocation());
10808 C->setSecondScheduleModifierLoc(
Record.readSourceLocation());
10809 C->setScheduleKindLoc(
Record.readSourceLocation());
10810 C->setCommaLoc(
Record.readSourceLocation());
10814 C->setNumForLoops(
Record.readSubExpr());
10815 for (
unsigned I = 0,
E =
C->NumberOfLoops; I <
E; ++I)
10816 C->setLoopNumIterations(I,
Record.readSubExpr());
10817 for (
unsigned I = 0,
E =
C->NumberOfLoops; I <
E; ++I)
10818 C->setLoopCounter(I,
Record.readSubExpr());
10819 C->setLParenLoc(
Record.readSourceLocation());
10823 C->setEventHandler(
Record.readSubExpr());
10824 C->setLParenLoc(
Record.readSourceLocation());
10833void OMPClauseReader::VisitOMPReadClause(
OMPReadClause *) {}
10838 if (
C->isExtended()) {
10839 C->setLParenLoc(
Record.readSourceLocation());
10840 C->setArgumentLoc(
Record.readSourceLocation());
10852 C->setLParenLoc(
Record.readSourceLocation());
10854 C->setFailParameterLoc(FailParameterLoc);
10856 C->setFailParameter(CKind);
10869void OMPClauseReader::VisitOMPWeakClause(
OMPWeakClause *) {}
10873void OMPClauseReader::VisitOMPSIMDClause(
OMPSIMDClause *) {}
10878 unsigned NumVars =
C->varlist_size();
10880 Vars.reserve(NumVars);
10881 for (
unsigned I = 0; I != NumVars; ++I)
10882 Vars.push_back(
Record.readSubExpr());
10883 C->setVarRefs(Vars);
10884 C->setIsTarget(
Record.readBool());
10885 C->setIsTargetSync(
Record.readBool());
10886 C->setLParenLoc(
Record.readSourceLocation());
10887 C->setVarLoc(
Record.readSourceLocation());
10891 C->setInteropVar(
Record.readSubExpr());
10892 C->setLParenLoc(
Record.readSourceLocation());
10893 C->setVarLoc(
Record.readSourceLocation());
10897 C->setInteropVar(
Record.readSubExpr());
10898 C->setLParenLoc(
Record.readSourceLocation());
10899 C->setVarLoc(
Record.readSourceLocation());
10904 C->setCondition(
Record.readSubExpr());
10905 C->setLParenLoc(
Record.readSourceLocation());
10910 C->setCondition(
Record.readSubExpr());
10911 C->setLParenLoc(
Record.readSourceLocation());
10916void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
10925void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
10927 C->setAtomicDefaultMemOrderKind(
10929 C->setLParenLoc(
Record.readSourceLocation());
10930 C->setAtomicDefaultMemOrderKindKwLoc(
Record.readSourceLocation());
10933void OMPClauseReader::VisitOMPAtClause(
OMPAtClause *
C) {
10935 C->setLParenLoc(
Record.readSourceLocation());
10936 C->setAtKindKwLoc(
Record.readSourceLocation());
10941 C->setLParenLoc(
Record.readSourceLocation());
10942 C->setSeverityKindKwLoc(
Record.readSourceLocation());
10946 C->setMessageString(
Record.readSubExpr());
10947 C->setLParenLoc(
Record.readSourceLocation());
10951 C->setLParenLoc(
Record.readSourceLocation());
10952 unsigned NumVars =
C->varlist_size();
10954 Vars.reserve(NumVars);
10955 for (
unsigned i = 0; i != NumVars; ++i)
10956 Vars.push_back(
Record.readSubExpr());
10957 C->setVarRefs(Vars);
10959 for (
unsigned i = 0; i != NumVars; ++i)
10960 Vars.push_back(
Record.readSubExpr());
10961 C->setPrivateCopies(Vars);
10966 C->setLParenLoc(
Record.readSourceLocation());
10967 unsigned NumVars =
C->varlist_size();
10969 Vars.reserve(NumVars);
10970 for (
unsigned i = 0; i != NumVars; ++i)
10971 Vars.push_back(
Record.readSubExpr());
10972 C->setVarRefs(Vars);
10974 for (
unsigned i = 0; i != NumVars; ++i)
10975 Vars.push_back(
Record.readSubExpr());
10976 C->setPrivateCopies(Vars);
10978 for (
unsigned i = 0; i != NumVars; ++i)
10979 Vars.push_back(
Record.readSubExpr());
10985 C->setLParenLoc(
Record.readSourceLocation());
10987 C->setKindLoc(
Record.readSourceLocation());
10988 C->setColonLoc(
Record.readSourceLocation());
10989 unsigned NumVars =
C->varlist_size();
10991 Vars.reserve(NumVars);
10992 for (
unsigned i = 0; i != NumVars; ++i)
10993 Vars.push_back(
Record.readSubExpr());
10994 C->setVarRefs(Vars);
10996 for (
unsigned i = 0; i != NumVars; ++i)
10997 Vars.push_back(
Record.readSubExpr());
10998 C->setPrivateCopies(Vars);
11000 for (
unsigned i = 0; i != NumVars; ++i)
11001 Vars.push_back(
Record.readSubExpr());
11002 C->setSourceExprs(Vars);
11004 for (
unsigned i = 0; i != NumVars; ++i)
11005 Vars.push_back(
Record.readSubExpr());
11006 C->setDestinationExprs(Vars);
11008 for (
unsigned i = 0; i != NumVars; ++i)
11009 Vars.push_back(
Record.readSubExpr());
11010 C->setAssignmentOps(Vars);
11014 C->setLParenLoc(
Record.readSourceLocation());
11015 unsigned NumVars =
C->varlist_size();
11017 Vars.reserve(NumVars);
11018 for (
unsigned i = 0; i != NumVars; ++i)
11019 Vars.push_back(
Record.readSubExpr());
11020 C->setVarRefs(Vars);
11025 C->setLParenLoc(
Record.readSourceLocation());
11026 C->setModifierLoc(
Record.readSourceLocation());
11027 C->setColonLoc(
Record.readSourceLocation());
11030 C->setQualifierLoc(NNSL);
11031 C->setNameInfo(DNI);
11033 unsigned NumVars =
C->varlist_size();
11035 Vars.reserve(NumVars);
11036 for (
unsigned i = 0; i != NumVars; ++i)
11037 Vars.push_back(
Record.readSubExpr());
11038 C->setVarRefs(Vars);
11040 for (
unsigned i = 0; i != NumVars; ++i)
11041 Vars.push_back(
Record.readSubExpr());
11042 C->setPrivates(Vars);
11044 for (
unsigned i = 0; i != NumVars; ++i)
11045 Vars.push_back(
Record.readSubExpr());
11046 C->setLHSExprs(Vars);
11048 for (
unsigned i = 0; i != NumVars; ++i)
11049 Vars.push_back(
Record.readSubExpr());
11050 C->setRHSExprs(Vars);
11052 for (
unsigned i = 0; i != NumVars; ++i)
11053 Vars.push_back(
Record.readSubExpr());
11054 C->setReductionOps(Vars);
11055 if (
C->getModifier() == OMPC_REDUCTION_inscan) {
11057 for (
unsigned i = 0; i != NumVars; ++i)
11058 Vars.push_back(
Record.readSubExpr());
11059 C->setInscanCopyOps(Vars);
11061 for (
unsigned i = 0; i != NumVars; ++i)
11062 Vars.push_back(
Record.readSubExpr());
11063 C->setInscanCopyArrayTemps(Vars);
11065 for (
unsigned i = 0; i != NumVars; ++i)
11066 Vars.push_back(
Record.readSubExpr());
11067 C->setInscanCopyArrayElems(Vars);
11073 C->setLParenLoc(
Record.readSourceLocation());
11074 C->setColonLoc(
Record.readSourceLocation());
11077 C->setQualifierLoc(NNSL);
11078 C->setNameInfo(DNI);
11080 unsigned NumVars =
C->varlist_size();
11082 Vars.reserve(NumVars);
11083 for (
unsigned I = 0; I != NumVars; ++I)
11084 Vars.push_back(
Record.readSubExpr());
11085 C->setVarRefs(Vars);
11087 for (
unsigned I = 0; I != NumVars; ++I)
11088 Vars.push_back(
Record.readSubExpr());
11089 C->setPrivates(Vars);
11091 for (
unsigned I = 0; I != NumVars; ++I)
11092 Vars.push_back(
Record.readSubExpr());
11093 C->setLHSExprs(Vars);
11095 for (
unsigned I = 0; I != NumVars; ++I)
11096 Vars.push_back(
Record.readSubExpr());
11097 C->setRHSExprs(Vars);
11099 for (
unsigned I = 0; I != NumVars; ++I)
11100 Vars.push_back(
Record.readSubExpr());
11101 C->setReductionOps(Vars);
11106 C->setLParenLoc(
Record.readSourceLocation());
11107 C->setColonLoc(
Record.readSourceLocation());
11110 C->setQualifierLoc(NNSL);
11111 C->setNameInfo(DNI);
11113 unsigned NumVars =
C->varlist_size();
11115 Vars.reserve(NumVars);
11116 for (
unsigned I = 0; I != NumVars; ++I)
11117 Vars.push_back(
Record.readSubExpr());
11118 C->setVarRefs(Vars);
11120 for (
unsigned I = 0; I != NumVars; ++I)
11121 Vars.push_back(
Record.readSubExpr());
11122 C->setPrivates(Vars);
11124 for (
unsigned I = 0; I != NumVars; ++I)
11125 Vars.push_back(
Record.readSubExpr());
11126 C->setLHSExprs(Vars);
11128 for (
unsigned I = 0; I != NumVars; ++I)
11129 Vars.push_back(
Record.readSubExpr());
11130 C->setRHSExprs(Vars);
11132 for (
unsigned I = 0; I != NumVars; ++I)
11133 Vars.push_back(
Record.readSubExpr());
11134 C->setReductionOps(Vars);
11136 for (
unsigned I = 0; I != NumVars; ++I)
11137 Vars.push_back(
Record.readSubExpr());
11138 C->setTaskgroupDescriptors(Vars);
11143 C->setLParenLoc(
Record.readSourceLocation());
11144 C->setColonLoc(
Record.readSourceLocation());
11146 C->setModifierLoc(
Record.readSourceLocation());
11147 unsigned NumVars =
C->varlist_size();
11149 Vars.reserve(NumVars);
11150 for (
unsigned i = 0; i != NumVars; ++i)
11151 Vars.push_back(
Record.readSubExpr());
11152 C->setVarRefs(Vars);
11154 for (
unsigned i = 0; i != NumVars; ++i)
11155 Vars.push_back(
Record.readSubExpr());
11156 C->setPrivates(Vars);
11158 for (
unsigned i = 0; i != NumVars; ++i)
11159 Vars.push_back(
Record.readSubExpr());
11162 for (
unsigned i = 0; i != NumVars; ++i)
11163 Vars.push_back(
Record.readSubExpr());
11164 C->setUpdates(Vars);
11166 for (
unsigned i = 0; i != NumVars; ++i)
11167 Vars.push_back(
Record.readSubExpr());
11168 C->setFinals(Vars);
11169 C->setStep(
Record.readSubExpr());
11170 C->setCalcStep(
Record.readSubExpr());
11172 for (
unsigned I = 0; I != NumVars + 1; ++I)
11173 Vars.push_back(
Record.readSubExpr());
11174 C->setUsedExprs(Vars);
11178 C->setLParenLoc(
Record.readSourceLocation());
11179 C->setColonLoc(
Record.readSourceLocation());
11180 unsigned NumVars =
C->varlist_size();
11182 Vars.reserve(NumVars);
11183 for (
unsigned i = 0; i != NumVars; ++i)
11184 Vars.push_back(
Record.readSubExpr());
11185 C->setVarRefs(Vars);
11186 C->setAlignment(
Record.readSubExpr());
11190 C->setLParenLoc(
Record.readSourceLocation());
11191 unsigned NumVars =
C->varlist_size();
11193 Exprs.reserve(NumVars);
11194 for (
unsigned i = 0; i != NumVars; ++i)
11195 Exprs.push_back(
Record.readSubExpr());
11196 C->setVarRefs(Exprs);
11198 for (
unsigned i = 0; i != NumVars; ++i)
11199 Exprs.push_back(
Record.readSubExpr());
11200 C->setSourceExprs(Exprs);
11202 for (
unsigned i = 0; i != NumVars; ++i)
11203 Exprs.push_back(
Record.readSubExpr());
11204 C->setDestinationExprs(Exprs);
11206 for (
unsigned i = 0; i != NumVars; ++i)
11207 Exprs.push_back(
Record.readSubExpr());
11208 C->setAssignmentOps(Exprs);
11212 C->setLParenLoc(
Record.readSourceLocation());
11213 unsigned NumVars =
C->varlist_size();
11215 Exprs.reserve(NumVars);
11216 for (
unsigned i = 0; i != NumVars; ++i)
11217 Exprs.push_back(
Record.readSubExpr());
11218 C->setVarRefs(Exprs);
11220 for (
unsigned i = 0; i != NumVars; ++i)
11221 Exprs.push_back(
Record.readSubExpr());
11222 C->setSourceExprs(Exprs);
11224 for (
unsigned i = 0; i != NumVars; ++i)
11225 Exprs.push_back(
Record.readSubExpr());
11226 C->setDestinationExprs(Exprs);
11228 for (
unsigned i = 0; i != NumVars; ++i)
11229 Exprs.push_back(
Record.readSubExpr());
11230 C->setAssignmentOps(Exprs);
11234 C->setLParenLoc(
Record.readSourceLocation());
11235 unsigned NumVars =
C->varlist_size();
11237 Vars.reserve(NumVars);
11238 for (
unsigned i = 0; i != NumVars; ++i)
11239 Vars.push_back(
Record.readSubExpr());
11240 C->setVarRefs(Vars);
11244 C->setDepobj(
Record.readSubExpr());
11245 C->setLParenLoc(
Record.readSourceLocation());
11249 C->setLParenLoc(
Record.readSourceLocation());
11250 C->setModifier(
Record.readSubExpr());
11251 C->setDependencyKind(
11253 C->setDependencyLoc(
Record.readSourceLocation());
11254 C->setColonLoc(
Record.readSourceLocation());
11255 C->setOmpAllMemoryLoc(
Record.readSourceLocation());
11256 unsigned NumVars =
C->varlist_size();
11258 Vars.reserve(NumVars);
11259 for (
unsigned I = 0; I != NumVars; ++I)
11260 Vars.push_back(
Record.readSubExpr());
11261 C->setVarRefs(Vars);
11262 for (
unsigned I = 0,
E =
C->getNumLoops(); I <
E; ++I)
11263 C->setLoopData(I,
Record.readSubExpr());
11269 C->setDevice(
Record.readSubExpr());
11270 C->setModifierLoc(
Record.readSourceLocation());
11271 C->setLParenLoc(
Record.readSourceLocation());
11275 C->setLParenLoc(
Record.readSourceLocation());
11276 bool HasIteratorModifier =
false;
11278 C->setMapTypeModifier(
11280 C->setMapTypeModifierLoc(I,
Record.readSourceLocation());
11281 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
11282 HasIteratorModifier =
true;
11284 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11285 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11288 C->setMapLoc(
Record.readSourceLocation());
11289 C->setColonLoc(
Record.readSourceLocation());
11290 auto NumVars =
C->varlist_size();
11291 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11292 auto TotalLists =
C->getTotalComponentListNum();
11293 auto TotalComponents =
C->getTotalComponentsNum();
11296 Vars.reserve(NumVars);
11297 for (
unsigned i = 0; i != NumVars; ++i)
11298 Vars.push_back(
Record.readExpr());
11299 C->setVarRefs(Vars);
11302 UDMappers.reserve(NumVars);
11303 for (
unsigned I = 0; I < NumVars; ++I)
11304 UDMappers.push_back(
Record.readExpr());
11305 C->setUDMapperRefs(UDMappers);
11307 if (HasIteratorModifier)
11308 C->setIteratorModifier(
Record.readExpr());
11311 Decls.reserve(UniqueDecls);
11312 for (
unsigned i = 0; i < UniqueDecls; ++i)
11314 C->setUniqueDecls(Decls);
11317 ListsPerDecl.reserve(UniqueDecls);
11318 for (
unsigned i = 0; i < UniqueDecls; ++i)
11319 ListsPerDecl.push_back(
Record.readInt());
11320 C->setDeclNumLists(ListsPerDecl);
11323 ListSizes.reserve(TotalLists);
11324 for (
unsigned i = 0; i < TotalLists; ++i)
11325 ListSizes.push_back(
Record.readInt());
11326 C->setComponentListSizes(ListSizes);
11329 Components.reserve(TotalComponents);
11330 for (
unsigned i = 0; i < TotalComponents; ++i) {
11333 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11336 C->setComponents(Components, ListSizes);
11340 C->setLParenLoc(
Record.readSourceLocation());
11341 C->setColonLoc(
Record.readSourceLocation());
11342 C->setAllocator(
Record.readSubExpr());
11343 unsigned NumVars =
C->varlist_size();
11345 Vars.reserve(NumVars);
11346 for (
unsigned i = 0; i != NumVars; ++i)
11347 Vars.push_back(
Record.readSubExpr());
11348 C->setVarRefs(Vars);
11353 C->setNumTeams(
Record.readSubExpr());
11354 C->setLParenLoc(
Record.readSourceLocation());
11359 C->setThreadLimit(
Record.readSubExpr());
11360 C->setLParenLoc(
Record.readSourceLocation());
11365 C->setPriority(
Record.readSubExpr());
11366 C->setLParenLoc(
Record.readSourceLocation());
11372 C->setGrainsize(
Record.readSubExpr());
11373 C->setModifierLoc(
Record.readSourceLocation());
11374 C->setLParenLoc(
Record.readSourceLocation());
11380 C->setNumTasks(
Record.readSubExpr());
11381 C->setModifierLoc(
Record.readSourceLocation());
11382 C->setLParenLoc(
Record.readSourceLocation());
11386 C->setHint(
Record.readSubExpr());
11387 C->setLParenLoc(
Record.readSourceLocation());
11392 C->setDistScheduleKind(
11394 C->setChunkSize(
Record.readSubExpr());
11395 C->setLParenLoc(
Record.readSourceLocation());
11396 C->setDistScheduleKindLoc(
Record.readSourceLocation());
11397 C->setCommaLoc(
Record.readSourceLocation());
11401 C->setDefaultmapKind(
11403 C->setDefaultmapModifier(
11405 C->setLParenLoc(
Record.readSourceLocation());
11406 C->setDefaultmapModifierLoc(
Record.readSourceLocation());
11407 C->setDefaultmapKindLoc(
Record.readSourceLocation());
11410void OMPClauseReader::VisitOMPToClause(
OMPToClause *
C) {
11411 C->setLParenLoc(
Record.readSourceLocation());
11413 C->setMotionModifier(
11415 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11417 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11418 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11419 C->setColonLoc(
Record.readSourceLocation());
11420 auto NumVars =
C->varlist_size();
11421 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11422 auto TotalLists =
C->getTotalComponentListNum();
11423 auto TotalComponents =
C->getTotalComponentsNum();
11426 Vars.reserve(NumVars);
11427 for (
unsigned i = 0; i != NumVars; ++i)
11428 Vars.push_back(
Record.readSubExpr());
11429 C->setVarRefs(Vars);
11432 UDMappers.reserve(NumVars);
11433 for (
unsigned I = 0; I < NumVars; ++I)
11434 UDMappers.push_back(
Record.readSubExpr());
11435 C->setUDMapperRefs(UDMappers);
11438 Decls.reserve(UniqueDecls);
11439 for (
unsigned i = 0; i < UniqueDecls; ++i)
11441 C->setUniqueDecls(Decls);
11444 ListsPerDecl.reserve(UniqueDecls);
11445 for (
unsigned i = 0; i < UniqueDecls; ++i)
11446 ListsPerDecl.push_back(
Record.readInt());
11447 C->setDeclNumLists(ListsPerDecl);
11450 ListSizes.reserve(TotalLists);
11451 for (
unsigned i = 0; i < TotalLists; ++i)
11452 ListSizes.push_back(
Record.readInt());
11453 C->setComponentListSizes(ListSizes);
11456 Components.reserve(TotalComponents);
11457 for (
unsigned i = 0; i < TotalComponents; ++i) {
11458 Expr *AssociatedExprPr =
Record.readSubExpr();
11459 bool IsNonContiguous =
Record.readBool();
11461 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11463 C->setComponents(Components, ListSizes);
11467 C->setLParenLoc(
Record.readSourceLocation());
11469 C->setMotionModifier(
11471 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11473 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11474 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11475 C->setColonLoc(
Record.readSourceLocation());
11476 auto NumVars =
C->varlist_size();
11477 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11478 auto TotalLists =
C->getTotalComponentListNum();
11479 auto TotalComponents =
C->getTotalComponentsNum();
11482 Vars.reserve(NumVars);
11483 for (
unsigned i = 0; i != NumVars; ++i)
11484 Vars.push_back(
Record.readSubExpr());
11485 C->setVarRefs(Vars);
11488 UDMappers.reserve(NumVars);
11489 for (
unsigned I = 0; I < NumVars; ++I)
11490 UDMappers.push_back(
Record.readSubExpr());
11491 C->setUDMapperRefs(UDMappers);
11494 Decls.reserve(UniqueDecls);
11495 for (
unsigned i = 0; i < UniqueDecls; ++i)
11497 C->setUniqueDecls(Decls);
11500 ListsPerDecl.reserve(UniqueDecls);
11501 for (
unsigned i = 0; i < UniqueDecls; ++i)
11502 ListsPerDecl.push_back(
Record.readInt());
11503 C->setDeclNumLists(ListsPerDecl);
11506 ListSizes.reserve(TotalLists);
11507 for (
unsigned i = 0; i < TotalLists; ++i)
11508 ListSizes.push_back(
Record.readInt());
11509 C->setComponentListSizes(ListSizes);
11512 Components.reserve(TotalComponents);
11513 for (
unsigned i = 0; i < TotalComponents; ++i) {
11514 Expr *AssociatedExprPr =
Record.readSubExpr();
11515 bool IsNonContiguous =
Record.readBool();
11517 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11519 C->setComponents(Components, ListSizes);
11523 C->setLParenLoc(
Record.readSourceLocation());
11524 auto NumVars =
C->varlist_size();
11525 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11526 auto TotalLists =
C->getTotalComponentListNum();
11527 auto TotalComponents =
C->getTotalComponentsNum();
11530 Vars.reserve(NumVars);
11531 for (
unsigned i = 0; i != NumVars; ++i)
11532 Vars.push_back(
Record.readSubExpr());
11533 C->setVarRefs(Vars);
11535 for (
unsigned i = 0; i != NumVars; ++i)
11536 Vars.push_back(
Record.readSubExpr());
11537 C->setPrivateCopies(Vars);
11539 for (
unsigned i = 0; i != NumVars; ++i)
11540 Vars.push_back(
Record.readSubExpr());
11544 Decls.reserve(UniqueDecls);
11545 for (
unsigned i = 0; i < UniqueDecls; ++i)
11547 C->setUniqueDecls(Decls);
11550 ListsPerDecl.reserve(UniqueDecls);
11551 for (
unsigned i = 0; i < UniqueDecls; ++i)
11552 ListsPerDecl.push_back(
Record.readInt());
11553 C->setDeclNumLists(ListsPerDecl);
11556 ListSizes.reserve(TotalLists);
11557 for (
unsigned i = 0; i < TotalLists; ++i)
11558 ListSizes.push_back(
Record.readInt());
11559 C->setComponentListSizes(ListSizes);
11562 Components.reserve(TotalComponents);
11563 for (
unsigned i = 0; i < TotalComponents; ++i) {
11564 auto *AssociatedExprPr =
Record.readSubExpr();
11566 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11569 C->setComponents(Components, ListSizes);
11573 C->setLParenLoc(
Record.readSourceLocation());
11574 auto NumVars =
C->varlist_size();
11575 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11576 auto TotalLists =
C->getTotalComponentListNum();
11577 auto TotalComponents =
C->getTotalComponentsNum();
11580 Vars.reserve(NumVars);
11581 for (
unsigned i = 0; i != NumVars; ++i)
11582 Vars.push_back(
Record.readSubExpr());
11583 C->setVarRefs(Vars);
11586 Decls.reserve(UniqueDecls);
11587 for (
unsigned i = 0; i < UniqueDecls; ++i)
11589 C->setUniqueDecls(Decls);
11592 ListsPerDecl.reserve(UniqueDecls);
11593 for (
unsigned i = 0; i < UniqueDecls; ++i)
11594 ListsPerDecl.push_back(
Record.readInt());
11595 C->setDeclNumLists(ListsPerDecl);
11598 ListSizes.reserve(TotalLists);
11599 for (
unsigned i = 0; i < TotalLists; ++i)
11600 ListSizes.push_back(
Record.readInt());
11601 C->setComponentListSizes(ListSizes);
11604 Components.reserve(TotalComponents);
11605 for (
unsigned i = 0; i < TotalComponents; ++i) {
11606 Expr *AssociatedExpr =
Record.readSubExpr();
11608 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11611 C->setComponents(Components, ListSizes);
11615 C->setLParenLoc(
Record.readSourceLocation());
11616 auto NumVars =
C->varlist_size();
11617 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11618 auto TotalLists =
C->getTotalComponentListNum();
11619 auto TotalComponents =
C->getTotalComponentsNum();
11622 Vars.reserve(NumVars);
11623 for (
unsigned i = 0; i != NumVars; ++i)
11624 Vars.push_back(
Record.readSubExpr());
11625 C->setVarRefs(Vars);
11629 Decls.reserve(UniqueDecls);
11630 for (
unsigned i = 0; i < UniqueDecls; ++i)
11632 C->setUniqueDecls(Decls);
11635 ListsPerDecl.reserve(UniqueDecls);
11636 for (
unsigned i = 0; i < UniqueDecls; ++i)
11637 ListsPerDecl.push_back(
Record.readInt());
11638 C->setDeclNumLists(ListsPerDecl);
11641 ListSizes.reserve(TotalLists);
11642 for (
unsigned i = 0; i < TotalLists; ++i)
11643 ListSizes.push_back(
Record.readInt());
11644 C->setComponentListSizes(ListSizes);
11647 Components.reserve(TotalComponents);
11648 for (
unsigned i = 0; i < TotalComponents; ++i) {
11649 Expr *AssociatedExpr =
Record.readSubExpr();
11651 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11654 C->setComponents(Components, ListSizes);
11658 C->setLParenLoc(
Record.readSourceLocation());
11659 auto NumVars =
C->varlist_size();
11660 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11661 auto TotalLists =
C->getTotalComponentListNum();
11662 auto TotalComponents =
C->getTotalComponentsNum();
11665 Vars.reserve(NumVars);
11666 for (
unsigned I = 0; I != NumVars; ++I)
11667 Vars.push_back(
Record.readSubExpr());
11668 C->setVarRefs(Vars);
11672 Decls.reserve(UniqueDecls);
11673 for (
unsigned I = 0; I < UniqueDecls; ++I)
11675 C->setUniqueDecls(Decls);
11678 ListsPerDecl.reserve(UniqueDecls);
11679 for (
unsigned I = 0; I < UniqueDecls; ++I)
11680 ListsPerDecl.push_back(
Record.readInt());
11681 C->setDeclNumLists(ListsPerDecl);
11684 ListSizes.reserve(TotalLists);
11685 for (
unsigned i = 0; i < TotalLists; ++i)
11686 ListSizes.push_back(
Record.readInt());
11687 C->setComponentListSizes(ListSizes);
11690 Components.reserve(TotalComponents);
11691 for (
unsigned I = 0; I < TotalComponents; ++I) {
11692 Expr *AssociatedExpr =
Record.readSubExpr();
11694 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11697 C->setComponents(Components, ListSizes);
11701 C->setLParenLoc(
Record.readSourceLocation());
11702 unsigned NumVars =
C->varlist_size();
11704 Vars.reserve(NumVars);
11705 for (
unsigned i = 0; i != NumVars; ++i)
11706 Vars.push_back(
Record.readSubExpr());
11707 C->setVarRefs(Vars);
11709 Vars.reserve(NumVars);
11710 for (
unsigned i = 0; i != NumVars; ++i)
11711 Vars.push_back(
Record.readSubExpr());
11712 C->setPrivateRefs(Vars);
11716 C->setLParenLoc(
Record.readSourceLocation());
11717 unsigned NumVars =
C->varlist_size();
11719 Vars.reserve(NumVars);
11720 for (
unsigned i = 0; i != NumVars; ++i)
11721 Vars.push_back(
Record.readSubExpr());
11722 C->setVarRefs(Vars);
11726 C->setLParenLoc(
Record.readSourceLocation());
11727 unsigned NumVars =
C->varlist_size();
11729 Vars.reserve(NumVars);
11730 for (
unsigned i = 0; i != NumVars; ++i)
11731 Vars.push_back(
Record.readSubExpr());
11732 C->setVarRefs(Vars);
11736 C->setLParenLoc(
Record.readSourceLocation());
11737 unsigned NumOfAllocators =
C->getNumberOfAllocators();
11739 Data.reserve(NumOfAllocators);
11740 for (
unsigned I = 0; I != NumOfAllocators; ++I) {
11742 D.Allocator =
Record.readSubExpr();
11743 D.AllocatorTraits =
Record.readSubExpr();
11744 D.LParenLoc =
Record.readSourceLocation();
11745 D.RParenLoc =
Record.readSourceLocation();
11747 C->setAllocatorsData(
Data);
11751 C->setLParenLoc(
Record.readSourceLocation());
11752 C->setModifier(
Record.readSubExpr());
11753 C->setColonLoc(
Record.readSourceLocation());
11754 unsigned NumOfLocators =
C->varlist_size();
11756 Locators.reserve(NumOfLocators);
11757 for (
unsigned I = 0; I != NumOfLocators; ++I)
11758 Locators.push_back(
Record.readSubExpr());
11759 C->setVarRefs(Locators);
11765 C->setLParenLoc(
Record.readSourceLocation());
11766 C->setKindKwLoc(
Record.readSourceLocation());
11767 C->setModifierKwLoc(
Record.readSourceLocation());
11772 C->setThreadID(
Record.readSubExpr());
11773 C->setLParenLoc(
Record.readSourceLocation());
11778 C->setLParenLoc(
Record.readSourceLocation());
11779 C->setBindKindLoc(
Record.readSourceLocation());
11783 C->setAlignment(
Record.readExpr());
11784 C->setLParenLoc(
Record.readSourceLocation());
11789 C->setSize(
Record.readSubExpr());
11790 C->setLParenLoc(
Record.readSourceLocation());
11794 C->setLParenLoc(
Record.readSourceLocation());
11795 C->setDependenceType(
11797 C->setDependenceLoc(
Record.readSourceLocation());
11798 C->setColonLoc(
Record.readSourceLocation());
11799 unsigned NumVars =
C->varlist_size();
11801 Vars.reserve(NumVars);
11802 for (
unsigned I = 0; I != NumVars; ++I)
11803 Vars.push_back(
Record.readSubExpr());
11804 C->setVarRefs(Vars);
11805 for (
unsigned I = 0,
E =
C->getNumLoops(); I <
E; ++I)
11806 C->setLoopData(I,
Record.readSubExpr());
11811 Record.readAttributes(Attrs);
11812 C->setAttrs(Attrs);
11813 C->setLocStart(
Record.readSourceLocation());
11814 C->setLParenLoc(
Record.readSourceLocation());
11815 C->setLocEnd(
Record.readSourceLocation());
11824 Set.Kind = readEnum<llvm::omp::TraitSet>();
11827 Selector.Kind = readEnum<llvm::omp::TraitSelector>();
11828 Selector.ScoreOrCondition =
nullptr;
11830 Selector.ScoreOrCondition = readExprRef();
11833 Property.Kind = readEnum<llvm::omp::TraitProperty>();
11842 if (Reader->ReadingKind == ASTReader::Read_Stmt) {
11847 for (
unsigned I = 0,
E =
Data->getNumClauses(); I <
E; ++I)
11849 Data->setClauses(Clauses);
11850 if (
Data->hasAssociatedStmt())
11852 for (
unsigned I = 0,
E =
Data->getNumChildren(); I <
E; ++I)
11857 unsigned NumVars =
readInt();
11859 for (
unsigned I = 0; I < NumVars; ++I)
11865 unsigned NumExprs =
readInt();
11867 for (
unsigned I = 0; I < NumExprs; ++I)
11877 switch (ClauseKind) {
11898 unsigned NumClauses =
readInt();
11900 for (
unsigned I = 0; I < NumClauses; ++I)
11959 LParenLoc, VarList, EndLoc);
11968 LParenLoc, IsReadOnly, VarList, EndLoc);
11977 LParenLoc, IsZero, VarList, EndLoc);
11986 LParenLoc, IsZero, VarList, EndLoc);
11992 AsyncExpr, EndLoc);
12000 DevNumExpr, QueuesLoc, QueueIdExprs,
12007 unsigned NumArchs =
readInt();
12009 for (
unsigned I = 0; I < NumArchs; ++I) {
12012 Archs.emplace_back(Ident,
Loc);
12016 LParenLoc, Archs, EndLoc);
12051 llvm_unreachable(
"Clause serialization not yet implemented");
12053 llvm_unreachable(
"Invalid Clause Kind");
12058 for (
unsigned I = 0; I < Clauses.size(); ++I)
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
static unsigned moduleKindForDiagnostic(ModuleKind Kind)
static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, ASTConsumer *Consumer)
Under non-PCH compilation the consumer receives the objc methods before receiving the implementation,...
static bool checkModuleCachePath(llvm::vfs::FileSystem &VFS, StringRef SpecificModuleCachePath, StringRef ExistingModuleCachePath, DiagnosticsEngine *Diags, const LangOptions &LangOpts, const PreprocessorOptions &PPOpts)
Check that the specified and the existing module cache paths are equivalent.
static llvm::Error doesntStartWithASTFileMagic(BitstreamCursor &Stream)
Whether Stream doesn't start with the AST/PCH file magic number 'CPCH'.
static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags)
static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool IsSystem, bool SystemHeaderWarningsInModule, bool Complain)
static void updateModuleTimestamp(ModuleFile &MF)
static unsigned getModuleFileIndexForTypeID(serialization::TypeID ID)
static void collectMacroDefinitions(const PreprocessorOptions &PPOpts, MacroDefinitionsMap &Macros, SmallVectorImpl< StringRef > *MacroNames=nullptr)
Collect the macro definitions provided by the given preprocessor options.
static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts, const PreprocessorOptions &ExistingPPOpts, bool ReadMacros, DiagnosticsEngine *Diags, FileManager &FileMgr, std::string &SuggestedPredefines, const LangOptions &LangOpts, OptionValidation Validation=OptionValidateContradictions)
Check the preprocessor options deserialized from the control block against the preprocessor options i...
static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool Complain)
static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method)
Move the given method to the back of the global list of methods.
static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps)
static bool isInterestingIdentifier(ASTReader &Reader, const IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
static bool parseModuleFileExtensionMetadata(const SmallVectorImpl< uint64_t > &Record, StringRef Blob, ModuleFileExtensionMetadata &Metadata)
Parse a record and blob containing module file extension metadata.
static Module * getTopImportImplicitModule(ModuleManager &ModuleMgr, Preprocessor &PP)
Return the top import module if it is implicit, nullptr otherwise.
static Decl * getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID)
static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II)
static void addMethodsToPool(Sema &S, ArrayRef< ObjCMethodDecl * > Methods, ObjCMethodList &List)
Add the given set of methods to the method list.
static bool isPredefinedType(serialization::TypeID ID)
static bool readBit(unsigned &Bits)
static std::optional< Type::TypeClass > getTypeClassForCode(TypeCode code)
static std::pair< unsigned, unsigned > readULEBKeyDataLength(const unsigned char *&P)
Read ULEB-encoded key length and data length.
static LLVM_DUMP_METHOD void dumpModuleIDMap(StringRef Name, const ContinuousRangeMap< Key, ModuleFile *, InitialCapacity > &Map)
@ OptionValidateStrictMatches
@ OptionValidateContradictions
static bool checkTargetOptions(const TargetOptions &TargetOpts, const TargetOptions &ExistingTargetOpts, DiagnosticsEngine *Diags, bool AllowCompatibleDifferences=true)
Compare the given set of target options against an existing set of target options.
#define CHECK_TARGET_OPT(Field, Name)
static bool checkLanguageOptions(const LangOptions &LangOpts, const LangOptions &ExistingLangOpts, DiagnosticsEngine *Diags, bool AllowCompatibleDifferences=true)
Compare the given set of language options against an existing set of language options.
static ASTFileSignature readASTFileSignature(StringRef PCH)
Reads and return the signature record from PCH's control block, or else returns 0.
static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID)
Given a cursor at the start of an AST file, scan ahead and drop the cursor into the start of the give...
static unsigned getIndexForTypeID(serialization::TypeID ID)
static uint64_t readULEB(const unsigned char *&P)
Defines the clang::ASTSourceDescriptor class, which abstracts clang modules and precompiled header fi...
static StringRef bytes(const std::vector< T, Allocator > &v)
Defines the Diagnostic-related interfaces.
enum clang::sema::@1651::IndirectLocalPathEntry::EntryKind Kind
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the Diagnostic IDs-related interfaces.
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::FileManager interface and associated types.
Defines the clang::FileSystemOptions interface.
llvm::DenseSet< const void * > Visited
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
static const Decl * getCanonicalDecl(const Decl *D)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::FileType FileType
llvm::MachO::Record Record
Defines the clang::MacroInfo and clang::MacroDirective classes.
Defines the clang::Module class, which describes a module in the source code.
Defines types useful for describing an Objective-C runtime.
Defines some OpenACC-specific enums and functions.
This file defines OpenMP AST classes for clauses.
Defines some OpenMP-specific enums and functions.
Defines an enumeration for C++ overloaded operators.
Defines the clang::Preprocessor interface.
static std::string getName(const CallEvent &Call)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::SanitizerKind enum.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for Objective-C.
Defines the clang::SourceLocation class and associated facilities.
Defines implementation details of the clang::SourceManager class.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TargetOptions class.
Defines the clang::TokenKind enum and support functions.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
Defines version macros and version-related utility functions for Clang.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.
virtual void HandleInterestingDecl(DeclGroupRef D)
HandleInterestingDecl - Handle the specified interesting declaration.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
CanQualType ObjCBuiltinSelTy
TranslationUnitDecl * getTranslationUnitDecl() const
CanQualType ARCUnbridgedCastTy
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C 'Class' type.
TypedefDecl * getCFConstantStringDecl() const
CanQualType SatUnsignedFractTy
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
ExternCContextDecl * getExternCContextDecl() const
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined 'SEL' type in Objective-C.
CanQualType UnsignedShortAccumTy
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
QualType getAutoRRefDeductType() const
C++11 deduction pattern for 'auto &&' type.
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type.
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any.
CanQualType SatLongAccumTy
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
CanQualType OMPArrayShapingTy
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
CanQualType UnsignedLongFractTy
CanQualType OMPIteratorTy
RawCommentList Comments
All comments in this translation unit.
CanQualType SatShortFractTy
CanQualType SatUnsignedAccumTy
CanQualType ArraySectionTy
CanQualType ObjCBuiltinIdTy
RecordDecl * getCFConstantStringTagDecl() const
CanQualType UnsignedFractTy
CanQualType ObjCBuiltinClassTy
CanQualType UnresolvedTemplateTy
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
OMPTraitInfo & getNewOMPTraitInfo()
Return a new OMPTraitInfo object owned by this context.
CanQualType UnsignedLongTy
CanQualType UnsignedLongAccumTy
CanQualType BoundMemberTy
CanQualType SatUnsignedShortFractTy
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
CanQualType PseudoObjectTy
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
CanQualType OCLClkEventTy
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated,...
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
CanQualType SatUnsignedShortAccumTy
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
CanQualType UnsignedInt128Ty
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
CanQualType UnsignedCharTy
CanQualType UnsignedShortFractTy
void * Allocate(size_t Size, unsigned Align=8) const
CanQualType UnsignedIntTy
TagDecl * getMSGuidTagDecl() const
Retrieve the implicitly-predeclared 'struct _GUID' declaration.
CanQualType UnsignedLongLongTy
CanQualType OCLReserveIDTy
CanQualType UnsignedShortTy
CanQualType SatUnsignedLongFractTy
void setcudaConfigureCallDecl(FunctionDecl *FD)
DiagnosticsEngine & getDiagnostics() const
CanQualType SatLongFractTy
CanQualType SatShortAccumTy
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CanQualType IncompleteMatrixIdxTy
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
BuiltinTemplateDecl * getTypePackElementDecl() const
CanQualType SatUnsignedLongAccumTy
void deduplicateMergedDefinitonsFor(NamedDecl *ND)
Clean up the merged definition list.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
void setPrimaryMergedDecl(Decl *D, Decl *Primary)
CanQualType UnsignedAccumTy
void setCFConstantStringType(QualType T)
virtual void MacroRead(serialization::MacroID ID, MacroInfo *MI)
A macro was read from the AST file.
virtual void SelectorRead(serialization::SelectorID iD, Selector Sel)
A selector was read from the AST file.
virtual void IdentifierRead(serialization::IdentifierID ID, IdentifierInfo *II)
An identifier was deserialized from the AST file.
An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files...
ASTIdentifierIterator(const ASTReader &Reader, bool SkipModules=false)
StringRef Next() override
Retrieve the next string in the identifier table and advances the iterator for the following string.
Abstract interface for callback invocations by the ASTReader.
virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain)
Receives the header search options.
virtual void ReadModuleMapFile(StringRef ModuleMapPath)
virtual bool needsInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the target options.
virtual bool visitInputFile(StringRef Filename, bool isSystem, bool isOverridden, bool isExplicitModule)
if needsInputFileVisitation returns true, this is called for each non-system input file of the AST Fi...
virtual bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts, bool Complain)
Receives the header search paths.
virtual bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain)
Receives the file system options.
virtual ~ASTReaderListener()
virtual bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain)
Receives the diagnostic options.
virtual void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata)
Indicates that a particular module file extension has been read.
virtual bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the language options.
virtual void visitImport(StringRef ModuleName, StringRef Filename)
If needsImportVisitation returns true, this is called for each AST file imported by this AST file.
virtual void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind)
This is called for each AST file loaded.
virtual bool needsImportVisitation() const
Returns true if this ASTReaderListener wants to receive the imports of the AST file via visitImport,...
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
virtual void ReadCounter(const serialization::ModuleFile &M, unsigned Value)
Receives COUNTER value.
virtual void ReadModuleName(StringRef ModuleName)
virtual bool needsSystemInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines)
Receives the preprocessor options.
Reads an AST files chain containing the contents of a translation unit.
std::optional< bool > isPreprocessedEntityInFileID(unsigned Index, FileID FID) override
Optionally returns true or false if the preallocated preprocessed entity with index Index came from f...
PreprocessedEntity * ReadPreprocessedEntity(unsigned Index) override
Read a preallocated preprocessed entity from the external source.
void markIdentifierUpToDate(const IdentifierInfo *II)
Note that this identifier is up-to-date.
void visitTopLevelModuleMaps(serialization::ModuleFile &MF, llvm::function_ref< void(FileEntryRef)> Visitor)
Visit all the top-level module maps loaded when building the given module file.
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) const
Retrieve the global submodule ID given a module and its local ID number.
ExtKind hasExternalDefinitions(const Decl *D) override
IdentifierTable & getIdentifierTable()
Retrieve the identifier table associated with the preprocessor.
ModuleManager & getModuleManager()
Retrieve the module manager.
bool isDeclIDFromModule(GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
friend class ASTIdentifierIterator
bool ReadSLocEntry(int ID) override
Read the source location entry with index ID.
void RecordSwitchCaseID(SwitchCase *SC, unsigned ID)
Record that the given ID maps to the given switch-case statement.
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.
static std::string ReadString(const RecordDataImpl &Record, unsigned &Idx)
void ReadDeclsToCheckForDeferredDiags(llvm::SmallSetVector< Decl *, 4 > &Decls) override
Read the set of decls to be checked for deferred diags.
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
@ ARR_Missing
The client can handle an AST file that cannot load because it is missing.
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
@ ARR_OutOfDate
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
@ ARR_VersionMismatch
The client can handle an AST file that cannot load because it was built with a different version of C...
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 > > &Exprs) override
void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl * > &Decls) override
Get the decls that are contained in a file in the Offset/Length range.
SourceRange ReadSkippedRange(unsigned Index) override
Read a preallocated skipped range from the external source.
serialization::TypeID getGlobalTypeID(ModuleFile &F, serialization::LocalTypeID LocalID) const
Map a local type ID within a given AST file into a global type ID.
void dump()
Dump information about the AST reader to standard error.
void AssignedLambdaNumbering(const CXXRecordDecl *Lambda) override
Notify the external source that a lambda was assigned a mangling number.
MacroInfo * ReadMacroRecord(ModuleFile &F, uint64_t Offset)
Reads the macro record located at the given offset.
SmallVector< std::pair< llvm::BitstreamCursor, serialization::ModuleFile * >, 8 > CommentsCursors
Cursors for comments blocks.
Selector getLocalSelector(ModuleFile &M, unsigned LocalID)
Retrieve a selector from the given module with its local ID number.
void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl * > &Decls) override
Read all of the declarations lexically stored in a declaration context.
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...
std::optional< ASTSourceDescriptor > getSourceDescriptor(unsigned ID) override
Return a descriptor for the corresponding module.
const serialization::reader::DeclContextLookupTable * getLoadedLookupTables(DeclContext *Primary) const
Get the loaded lookup tables for Primary, if any.
QualType getLocalType(ModuleFile &F, serialization::LocalTypeID LocalID)
Resolve a local type ID within a given AST file into a type.
void ClearSwitchCaseIDs()
SourceLocation ReadSourceLocation(ModuleFile &MF, RawLocEncoding Raw, LocSeq *Seq=nullptr) const
Read a source location from raw form.
void SetGloballyVisibleDecls(IdentifierInfo *II, const SmallVectorImpl< GlobalDeclID > &DeclIDs, SmallVectorImpl< Decl * > *Decls=nullptr)
Set the globally-visible declarations associated with the given identifier.
bool loadGlobalIndex()
Attempts to load the global index.
void ReadComments() override
Loads comments ranges.
SourceManager & getSourceManager() const
SourceLocation getSourceLocationForDeclID(GlobalDeclID ID)
Returns the source location for the decl ID.
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind NameVisibility, SourceLocation ImportLoc)
Make the entities in the given module and any of its (non-explicit) submodules visible to name lookup...
void finalizeForWriting()
Finalizes the AST reader's state before writing an AST file to disk.
Sema * getSema()
Retrieve the semantic analysis object used to analyze the translation unit in which the precompiled h...
CXXCtorInitializer ** GetExternalCXXCtorInitializers(uint64_t Offset) override
Read the contents of a CXXCtorInitializer array.
void visitInputFileInfos(serialization::ModuleFile &MF, bool IncludeSystem, llvm::function_ref< void(const serialization::InputFileInfo &IFI, bool IsSystem)> Visitor)
Visit all the input file infos of the given module file.
void StartTranslationUnit(ASTConsumer *Consumer) override
Function that will be invoked when we begin parsing a new translation unit involving this external AS...
LocalDeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, GlobalDeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
void resolvePendingMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo)
bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) override
Finds all the visible declarations with a given name.
void ReadTentativeDefinitions(SmallVectorImpl< VarDecl * > &TentativeDefs) override
Read the set of tentative definitions known to the external Sema source.
Decl * GetExternalDecl(GlobalDeclID ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
GlobalDeclID ReadDeclID(ModuleFile &F, const RecordDataImpl &Record, unsigned &Idx)
Reads a declaration ID from the given position in a record in the given module.
llvm::Expected< SourceLocation::UIntTy > readSLocOffset(ModuleFile *F, unsigned Index)
Try to read the offset of the SLocEntry at the given index in the given module file.
void CompleteRedeclChain(const Decl *D) override
If any redeclarations of D have been imported since it was last checked, this digs out those redeclar...
static llvm::Error ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, unsigned BlockID, uint64_t *StartOfBlockOffset=nullptr)
ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the specified cursor.
void SetIdentifierInfo(serialization::IdentifierID ID, IdentifierInfo *II)
serialization::PreprocessedEntityID getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const
Determine the global preprocessed entity ID that corresponds to the given local ID within the given m...
std::pair< unsigned, unsigned > findPreprocessedEntitiesInRange(SourceRange Range) override
Returns a pair of [Begin, End) indices of preallocated preprocessed entities that Range encompasses.
IdentifierInfo * get(StringRef Name) override
Retrieve the IdentifierInfo for the named identifier.
IdentifierInfo * getLocalIdentifier(ModuleFile &M, uint64_t LocalID)
void visitInputFiles(serialization::ModuleFile &MF, bool IncludeSystem, bool Complain, llvm::function_ref< void(const serialization::InputFile &IF, bool isSystem)> Visitor)
Visit all the input files of the given module file.
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
llvm::iterator_range< ModuleDeclIterator > getModuleFileLevelDecls(ModuleFile &Mod)
Stmt * GetExternalDeclStmt(uint64_t Offset) override
Resolve the offset of a statement into a statement.
Selector GetExternalSelector(serialization::SelectorID ID) override
Resolve a selector ID into a selector.
unsigned getTotalNumSelectors() const
Returns the number of selectors found in the chain.
MacroInfo * getMacro(serialization::MacroID ID)
Retrieve the macro with the given ID.
void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined) override
Load the set of used but not defined functions or variables with internal linkage,...
void ReadDelegatingConstructors(SmallVectorImpl< CXXConstructorDecl * > &Decls) override
Read the set of delegating constructors known to the external Sema source.
QualType GetType(serialization::TypeID ID)
Resolve a type ID into a type, potentially building a new type.
void addPendingMacro(IdentifierInfo *II, ModuleFile *M, uint32_t MacroDirectivesOffset)
Add a macro to deserialize its macro directive history.
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx, LocSeq *Seq=nullptr)
Read a source range.
GlobalDeclID getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const
Map from a local declaration ID within a given module to a global declaration ID.
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WeakIDs) override
Read the set of weak, undeclared identifiers known to the external Sema source.
void completeVisibleDeclsMap(const DeclContext *DC) override
Load all external visible decls in the given DeclContext.
void warnStackExhausted(SourceLocation Loc)
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
IdentifierResolver & getIdResolver()
Get the identifier resolver used for name lookup / updates in the translation unit scope.
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)
Read the control block for the named AST file.
void ReadExtVectorDecls(SmallVectorImpl< TypedefNameDecl * > &Decls) override
Read the set of ext_vector type declarations known to the external Sema source.
void ResolveImportedPath(ModuleFile &M, std::string &Filename)
If we are loading a relocatable PCH or module file, and the filename is not an absolute path,...
SmallVector< GlobalDeclID, 16 > PreloadedDeclIDs
std::pair< SourceLocation, StringRef > getModuleImportLoc(int ID) override
Retrieve the module import location and module name for the given source manager entry ID.
void ReadUnusedFileScopedDecls(SmallVectorImpl< const DeclaratorDecl * > &Decls) override
Read the set of unused file-scope declarations known to the external Sema source.
void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation > > &Sels) override
Read the set of referenced selectors known to the external Sema source.
Selector DecodeSelector(serialization::SelectorID Idx)
ASTReadResult ReadAST(StringRef FileName, ModuleKind Type, SourceLocation ImportLoc, unsigned ClientLoadCapabilities, ModuleFile **NewLoadedModuleFile=nullptr)
Load the AST file designated by the given file name.
StringRef getOriginalSourceFile()
Retrieve the name of the original source file name for the primary module file.
std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx)
unsigned getModuleFileID(ModuleFile *M)
Get an ID for the given module file.
IdentifierInfo * DecodeIdentifierInfo(serialization::IdentifierID ID)
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons.
@ Success
The control block was read successfully.
@ ConfigurationMismatch
The AST file was written with a different language/target configuration.
@ OutOfDate
The AST file is out-of-date relative to its input files, and needs to be regenerated.
@ Failure
The AST file itself appears corrupted.
@ VersionMismatch
The AST file was written by a different version of Clang.
@ HadErrors
The AST file has errors.
@ Missing
The AST file was missing.
static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx)
Read a version tuple.
Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx)
Reads a token out of a record.
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
serialization::IdentifierID getGlobalIdentifierID(ModuleFile &M, uint64_t LocalID)
void ReadLateParsedTemplates(llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate > > &LPTMap) override
Read the set of late parsed template functions for this source.
IdentifierIterator * getIdentifiers() override
Retrieve an iterator into the set of all identifiers in all loaded AST files.
void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables) override
Read the set of used vtables known to the external Sema source.
bool isGlobalIndexUnavailable() const
Determine whether we tried to load the global index, but failed, e.g., because it is out-of-date or d...
uint32_t GetNumExternalSelectors() override
Returns the number of selectors known to the external AST source.
void updateOutOfDateSelector(Selector Sel) override
Load the contents of the global method pool for a given selector if necessary.
Decl * GetExistingDecl(GlobalDeclID ID)
Resolve a declaration ID into a declaration.
static llvm::BitVector ReadBitVector(const RecordData &Record, const StringRef Blob)
ModuleFile * getLocalModuleFile(ModuleFile &M, unsigned ID) const
Retrieve the module file with a given local ID within the specified ModuleFile.
void LoadSelector(Selector Sel)
Load a selector from disk, registering its ID if it exists.
void ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag)
void makeNamesVisible(const HiddenNames &Names, Module *Owner)
Make the names within this set of hidden names visible.
void UpdateSema()
Update the state of Sema after loading some additional modules.
Decl * GetDecl(GlobalDeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache, ASTContext *Context, const PCHContainerReader &PCHContainerRdr, ArrayRef< std::shared_ptr< ModuleFileExtension > > Extensions, StringRef isysroot="", DisableValidationForModuleKind DisableValidationKind=DisableValidationForModuleKind::None, bool AllowASTWithCompilerErrors=false, bool AllowConfigurationMismatch=false, bool ValidateSystemInputs=false, bool ValidateASTInputFilesContent=false, bool UseGlobalIndex=true, std::unique_ptr< llvm::Timer > ReadTimer={})
Load the AST file and validate its contents against the given Preprocessor.
int getSLocEntryID(SourceLocation::UIntTy SLocOffset) override
Get the index ID for the loaded SourceLocation offset.
void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending) override
Read the set of pending instantiations known to the external Sema source.
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
CXXTemporary * ReadCXXTemporary(ModuleFile &F, const RecordData &Record, unsigned &Idx)
void ReadKnownNamespaces(SmallVectorImpl< NamespaceDecl * > &Namespaces) override
Load the set of namespaces that are known to the external source, which will be used during typo corr...
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
void PrintStats() override
Print some statistics about AST usage.
void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef)
Note that MergedDef is a redefinition of the canonical definition Def, so Def should be visible whene...
serialization::SelectorID getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const
Retrieve the global selector ID that corresponds to this the local selector ID in a given module.
void StartedDeserializing() override
Notify ASTReader that we started deserialization of a decl or type so until FinishedDeserializing is ...
void ReadMethodPool(Selector Sel) override
Load the contents of the global method pool for a given selector.
void InitializeContext()
Initializes the ASTContext.
CXXBaseSpecifier * GetExternalCXXBaseSpecifiers(uint64_t Offset) override
Resolve the offset of a set of C++ base specifiers in the decl stream into an array of specifiers.
FileManager & getFileManager() const
static bool isAcceptableASTFile(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts, const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts, StringRef ExistingModuleCachePath, bool RequireStrictOptionMatches=false)
Determine whether the given AST file is acceptable to load into a translation unit with the given lan...
void FinishedDeserializing() override
Notify ASTReader that we finished the deserialization of a decl or type.
void updateOutOfDateIdentifier(const IdentifierInfo &II) override
Update an out-of-date identifier.
void ReadDefinedMacros() override
Read the set of macros defined by this external macro source.
HeaderFileInfo GetHeaderFileInfo(FileEntryRef FE) override
Read the header file information for the given file entry.
serialization::MacroID getGlobalMacroID(ModuleFile &M, unsigned LocalID)
Retrieve the global macro ID corresponding to the given local ID within the given module file.
An object for streaming information from a record.
bool readBool()
Read a boolean value, advancing Idx.
uint32_t readUInt32()
Read a 32-bit unsigned value; required to satisfy BasicReader.
llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem)
Read an arbitrary constant value, advancing Idx.
TemplateArgumentLoc readTemplateArgumentLoc()
Reads a TemplateArgumentLoc, advancing Idx.
void readTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Reads the location information for a type.
void readUnresolvedSet(LazyASTUnresolvedSet &Set)
Read a UnresolvedSet structure, advancing Idx.
void readTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, bool Canonicalize=false)
Read a template argument array, advancing Idx.
void readQualifierInfo(QualifierInfo &Info)
DeclarationNameLoc readDeclarationNameLoc(DeclarationName Name)
Read a declaration name, advancing Idx.
CXXBaseSpecifier readCXXBaseSpecifier()
Read a C++ base specifier, advancing Idx.
Expected< unsigned > readRecord(llvm::BitstreamCursor &Cursor, unsigned AbbrevID)
Reads a record with id AbbrevID from Cursor, resetting the internal state.
DeclarationNameInfo readDeclarationNameInfo()
IdentifierInfo * readIdentifier()
TemplateArgumentLocInfo readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind)
Reads a TemplateArgumentLocInfo appropriate for the given TemplateArgument kind, advancing Idx.
TemplateArgument readTemplateArgument(bool Canonicalize)
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
TypeSourceInfo * readTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
void readTemplateArgumentListInfo(TemplateArgumentListInfo &Result)
TypeCoupledDeclRefInfo readTypeCoupledDeclRefInfo()
void skipInts(unsigned N)
Skips the specified number of values.
GlobalDeclID readDeclID()
Reads a declaration ID from the given position in this record.
SourceRange readSourceRange(LocSeq *Seq=nullptr)
Read a source range, advancing Idx.
NestedNameSpecifierLoc readNestedNameSpecifierLoc()
Return a nested name specifier, advancing Idx.
ConceptReference * readConceptReference()
void readOMPChildren(OMPChildren *Data)
Read an OpenMP children, advancing Idx.
OMPClause * readOMPClause()
Read an OpenMP clause, advancing Idx.
void readOpenACCClauseList(MutableArrayRef< const OpenACCClause * > Clauses)
Read a list of OpenACC clauses into the passed SmallVector.
OMPTraitInfo * readOMPTraitInfo()
Read an OMPTraitInfo object, advancing Idx.
TemplateParameterList * readTemplateParameterList()
Read a template parameter list, advancing Idx.
OpenACCClause * readOpenACCClause()
Read an OpenACC clause, advancing Idx.
llvm::SmallVector< Expr * > readOpenACCVarList()
Read a list of Exprs used for a var-list.
CXXCtorInitializer ** readCXXCtorInitializers()
Read a CXXCtorInitializer array, advancing Idx.
Stmt * readStmt()
Reads a statement.
const ASTTemplateArgumentListInfo * readASTTemplateArgumentListInfo()
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.
llvm::SmallVector< Expr * > readOpenACCIntExprList()
Read a list of Exprs used for a int-expr-list.
Expr * readSubExpr()
Reads a sub-expression operand during statement reading.
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
Wrapper for source info for array parameter types.
Wrapper for source info for arrays.
void setLBracketLoc(SourceLocation Loc)
void setRBracketLoc(SourceLocation Loc)
void setSizeExpr(Expr *Size)
void setRParenLoc(SourceLocation Loc)
void setLParenLoc(SourceLocation Loc)
void setKWLoc(SourceLocation Loc)
Attr - This represents one attribute.
Type source information for an attributed type.
void setAttr(const Attr *A)
void setConceptReference(ConceptReference *CR)
void setRParenLoc(SourceLocation Loc)
Type source information for an btf_tag attributed type.
Wrapper for source info for block pointers.
void setCaretLoc(SourceLocation Loc)
Wrapper for source info for builtin types.
void setWrittenTypeSpec(TypeSpecifierType written)
bool needsExtraLocalData() const
void setModeAttr(bool written)
void setBuiltinLoc(SourceLocation Loc)
void setWrittenWidthSpec(TypeSpecifierWidth written)
void setWrittenSignSpec(TypeSpecifierSign written)
Represents a base class of a C++ class.
Represents a C++ constructor within a class.
Represents a C++ base or member initializer.
void setSourceOrder(int Pos)
Set the source order of this initializer.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
unsigned getLambdaIndexInContext() const
Retrieve the index of this lambda within the context declaration returned by getLambdaContextDecl().
Represents a C++ temporary.
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
bool visitInputFile(StringRef Filename, bool isSystem, bool isOverridden, bool isExplicitModule) override
if needsInputFileVisitation returns true, this is called for each non-system input file of the AST Fi...
bool ReadFullVersionInformation(StringRef FullVersion) override
Receives the full Clang version information.
bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain) override
Receives the file system options.
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
void ReadModuleMapFile(StringRef ModuleMapPath) override
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
void ReadModuleName(StringRef ModuleName) override
bool needsInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata) override
Indicates that a particular module file extension has been read.
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind) override
This is called for each AST file loaded.
bool needsSystemInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
A reference to a concept and its template args, as it appears in the code.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const TypeClass * getTypePtr() const
An object that helps properly build a continuous range map from a set of values.
A map from continuous integer ranges to some value, with a very specialized interface.
void insertOrReplace(const value_type &Val)
typename Representation::const_iterator const_iterator
typename Representation::iterator iterator
Wrapper for source info for pointers decayed from arrays and functions.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void setMustBuildLookupTable()
Mark that there are external lexical declarations that we need to include in our lookup table (and th...
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context.
bool isDeclInLexicalTraversal(const Decl *D) const
Determine whether the given declaration is stored in the list of declarations lexically within this c...
unsigned getModuleFileIndex() const
DeclID getRawValue() const
unsigned getLocalDeclIndex() const
uint64_t DeclID
An ID number that refers to a declaration in an AST file.
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
Kind
Lists the kind of concrete classes of Decl.
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
SourceLocation getLocation() const
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
GlobalDeclID getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
DeclarationNameLoc - Additional source/type location info for a declaration name.
static DeclarationNameLoc makeNamedTypeLoc(TypeSourceInfo *TInfo)
Construct location information for a constructor, destructor or conversion operator.
static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc)
Construct location information for a literal C++ operator.
static DeclarationNameLoc makeCXXOperatorNameLoc(SourceLocation BeginLoc, SourceLocation EndLoc)
Construct location information for a non-literal C++ operator.
The name of a declaration.
NameKind
The kind of the name stored in this DeclarationName.
@ CXXConversionFunctionName
Represents a ValueDecl that came out of a declarator.
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
void setTemplateNameLoc(SourceLocation Loc)
void setAttrNameLoc(SourceLocation loc)
void setAttrOperandParensRange(SourceRange range)
void setAttrExprOperand(Expr *e)
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
void setNameLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
unsigned getNumArgs() const
void setTemplateKeywordLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateNameLoc(SourceLocation Loc)
ArrayRef< TemplateArgument > template_arguments() const
void setNameLoc(SourceLocation Loc)
A little helper class used to produce diagnostics.
Carries a Clang diagnostic in an llvm::Error.
static llvm::Error create(SourceLocation Loc, PartialDiagnostic Diag)
Creates a new DiagnosticError that contains the given diagnostic at the given location.
bool wasUpgradedFromWarning() const
Whether this mapping attempted to map the diagnostic to a warning, but was overruled because the diag...
bool isErrorOrFatal() const
void setSeverity(diag::Severity Value)
static DiagnosticMapping deserialize(unsigned Bits)
Deserialize a mapping.
void setUpgradedFromWarning(bool Value)
Options for controlling the compiler diagnostics engine.
std::vector< std::string > SystemHeaderWarningsModules
The list of -Wsystem-headers-in-module=... options used to override whether -Wsystem-headers is enabl...
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
bool getEnableAllWarnings() const
Level
The level of the diagnostic, after it has been through mapping.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
bool getSuppressSystemWarnings() const
bool getWarningsAsErrors() const
diag::Severity getExtensionHandlingBehavior() const
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
StringRef getName() const
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Wrapper for source info for enum types.
This represents one expression.
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap'ed memor...
uint32_t getGeneration() const
Get the current generation of this AST source.
Represents difference between two FPOptions values.
static FPOptionsOverride getFromOpaqueInt(storage_type I)
FPOptions applyOverrides(FPOptions Base)
static FPOptions getFromOpaqueInt(storage_type Value)
Represents a member of a struct/union/class.
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
time_t getModificationTime() const
StringRef getName() const
The name of this FileEntry.
Cached information about one file (either on disk or in the virtual file system).
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Implements support for file system lookup, file system caching, and directory search management.
llvm::vfs::FileSystem & getVirtualFileSystem() const
OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Get a FileEntryRef if it exists, without doing anything on error.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(FileEntryRef Entry, bool isVolatile=false, bool RequiresNullTerminator=true, std::optional< int64_t > MaybeLimit=std::nullopt)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
FileEntryRef getVirtualFileRef(StringRef Filename, off_t Size, time_t ModificationTime)
Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...
llvm::ErrorOr< const FileEntry * > getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
Keeps track of options that affect how file operations are performed.
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
Represents a function declaration or definition.
void setLazyBody(uint64_t Offset)
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
Wrapper for source info for functions.
unsigned getNumParams() const
void setLocalRangeBegin(SourceLocation L)
void setLParenLoc(SourceLocation Loc)
void setParam(unsigned i, ParmVarDecl *VD)
void setRParenLoc(SourceLocation Loc)
void setLocalRangeEnd(SourceLocation L)
void setExceptionSpecRange(SourceRange R)
static std::pair< GlobalModuleIndex *, llvm::Error > readIndex(llvm::StringRef Path)
Read a global index file for the given directory.
One of these records is kept for each identifier that is lexed.
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
bool isCPlusPlusOperatorKeyword() const
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
void setIsPoisoned(bool Value=true)
setIsPoisoned - Mark this identifier as poisoned.
bool isFromAST() const
Return true if the identifier in its current state was loaded from an AST file.
bool isPoisoned() const
Return true if this token has been poisoned.
bool hasRevertedTokenIDToIdentifier() const
True if revertTokenIDToIdentifier() was called.
tok::NotableIdentifierKind getNotableIdentifierID() const
void setOutOfDate(bool OOD)
Set whether the information for this identifier is out of date with respect to the external source.
tok::ObjCKeywordKind getObjCKeywordID() const
Return the Objective-C keyword ID for the this identifier.
void setObjCOrBuiltinID(unsigned ID)
void revertTokenIDToIdentifier()
Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2 compatibility.
bool isOutOfDate() const
Determine whether the information for this identifier is out of date with respect to the external sou...
void setChangedSinceDeserialization()
Note that this identifier has changed since it was loaded from an AST file.
void * getFETokenInfo() const
Get and set FETokenInfo.
StringRef getName() const
Return the actual identifier string.
bool isExtensionToken() const
get/setExtension - Initialize information about whether or not this language token is an extension.
An iterator that walks over all of the known identifiers in the lookup table.
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
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...
llvm::iterator_range< iterator > decls(DeclarationName Name)
Returns a range of decls with the name 'Name'.
Implements an efficient mapping from strings to IdentifierInfo nodes.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
In-memory cache for modules.
llvm::MemoryBuffer * lookupPCM(llvm::StringRef Filename) const
Get a pointer to the pCM if it exists; else nullptr.
Record the location of an inclusion directive, such as an #include or #import statement.
InclusionKind
The kind of inclusion directives known to the preprocessor.
Represents a field injected from an anonymous union/struct into the parent scope.
Wrapper for source info for injected class names of class templates.
void setAmpLoc(SourceLocation Loc)
PragmaMSPointersToMembersKind
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
clang::ObjCRuntime ObjCRuntime
SanitizerSet Sanitize
Set of enabled sanitizers.
CommentOptions CommentOpts
Options for parsing comments.
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
std::string CurrentModule
The name of the current module, of which the main source file is a part.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
An UnresolvedSet-like class that might not have been loaded from the external AST source yet.
Used to hold and unique data used to represent #line information.
unsigned getLineTableFilenameID(StringRef Str)
void AddEntry(FileID FID, const std::vector< LineEntry > &Entries)
Add a new line entry that has already been encoded into the internal representation of the line table...
static LocalDeclID get(ASTReader &Reader, serialization::ModuleFile &MF, DeclID ID)
Record the location of a macro definition.
Encapsulates changes to the "macros namespace" (the location where the macro name became active,...
void setPrevious(MacroDirective *Prev)
Set previous definition of the macro with the same name.
Records the location of a macro expansion.
Encapsulates the data about a macro definition (e.g.
void setUsedForHeaderGuard(bool Val)
void setHasCommaPasting()
void setDefinitionEndLoc(SourceLocation EndLoc)
Set the location of the last token in the macro.
void setParameterList(ArrayRef< IdentifierInfo * > List, llvm::BumpPtrAllocator &PPAllocator)
Set the specified list of identifiers as the parameter list for this macro.
llvm::MutableArrayRef< Token > allocateTokens(unsigned NumTokens, llvm::BumpPtrAllocator &PPAllocator)
void setIsFunctionLike()
Function/Object-likeness.
void setIsC99Varargs()
Varargs querying methods. This can only be set for function-like macros.
void setIsUsed(bool Val)
Set the value of the IsUsed flag.
void setExpansionLoc(SourceLocation Loc)
void setAttrRowOperand(Expr *e)
void setAttrColumnOperand(Expr *e)
void setAttrOperandParensRange(SourceRange range)
void setAttrNameLoc(SourceLocation loc)
Wrapper for source info for member pointers.
void setStarLoc(SourceLocation Loc)
void setClassTInfo(TypeSourceInfo *TI)
void addLinkAsDependency(Module *Mod)
Make module to use export_as as the link dependency name if enough information is available or add it...
std::pair< Module *, bool > findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework, bool IsExplicit)
Find a new module or submodule, or create it if it does not already exist.
void setUmbrellaDirAsWritten(Module *Mod, DirectoryEntryRef UmbrellaDir, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)
Sets the umbrella directory of the given module to the given directory.
void setUmbrellaHeaderAsWritten(Module *Mod, FileEntryRef UmbrellaHeader, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)
Sets the umbrella header of the given module to the given header.
void resolveLinkAsDependencies(Module *Mod)
Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...
ModuleHeaderRole
Flags describing the role of a module header.
void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)
Adds this header to the given module.
Describes a module or submodule.
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
void addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target)
Add the given feature requirement to the list of features required by this module.
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
unsigned IsUnimportable
Whether this module has declared itself unimportable, either because it's missing a requirement from ...
NameVisibilityKind NameVisibility
The visibility of names within this particular module.
NameVisibilityKind
Describes the visibility of the various names within a particular module.
@ Hidden
All of the names in this module are hidden.
@ AllVisible
All of the names in this module are visible.
SourceLocation DefinitionLoc
The location of the module definition.
SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders
Headers that are mentioned in the module map file but could not be found on the file system.
ModuleKind Kind
The kind of this module.
void addTopHeaderFilename(StringRef Filename)
Add a top-level header filename associated with this module.
bool isUnimportable() const
Determine whether this module has been declared unimportable.
void setASTFile(OptionalFileEntryRef File)
Set the serialized AST file for the top-level module of this module.
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers).
std::string Name
The name of this module.
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...
unsigned ModuleMapIsPrivate
Whether this module came from a "private" module map, found next to a regular (public) module map.
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used.
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
std::optional< Header > getUmbrellaHeaderAsWritten() const
Retrieve the umbrella header as written.
SmallVector< Requirement, 2 > Requirements
The set of language features required to use this module.
OptionalDirectoryEntryRef Directory
The build directory of this module.
unsigned NamedModuleHasInit
Whether this C++20 named modules doesn't need an initializer.
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
ASTFileSignature Signature
The module signature.
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e....
void getExportedModules(SmallVectorImpl< Module * > &Exported) const
Appends this module's list of exported modules to Exported.
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
std::optional< DirectoryName > getUmbrellaDirAsWritten() const
Retrieve the umbrella directory as written.
std::string ExportAsModule
The module through which entities defined in this module will eventually be exposed,...
unsigned IsAvailable
Whether this module is available in the current translation unit.
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
OptionalFileEntryRef getASTFile() const
The serialized AST file for this module, if one was created.
std::vector< Conflict > Conflicts
The list of conflicts.
This represents a decl that may have a name.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a C++ namespace alias.
Represent a C++ namespace.
Class that aids in the construction of nested-name-specifiers along with source-location information ...
A C++ nested-name-specifier augmented with source location information.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
static std::string getOwningModuleNameForDiagnostic(const Decl *D)
Get the best name we know for the module that owns the given declaration, or an empty string if the d...
This represents 'acq_rel' clause in the '#pragma omp atomic|flush' directives.
This represents 'acquire' clause in the '#pragma omp atomic|flush' directives.
This represents clause 'affinity' in the '#pragma omp task'-based directives.
static OMPAffinityClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N locator items.
This represents the 'align' clause in the '#pragma omp allocate' directive.
This represents clause 'aligned' in the '#pragma omp ...' directives.
static OMPAlignedClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
This represents clause 'allocate' in the '#pragma omp ...' directives.
static OMPAllocateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'allocator' clause in the '#pragma omp ...' directive.
This represents 'at' clause in the '#pragma omp error' directive.
This represents 'atomic_default_mem_order' clause in the '#pragma omp requires' directive.
This represents 'bind' clause in the '#pragma omp ...' directives.
static OMPBindClause * CreateEmpty(const ASTContext &C)
Build an empty 'bind' clause.
This represents 'capture' clause in the '#pragma omp atomic' directive.
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C)
OMPClauseReader(ASTRecordReader &Record)
void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C)
RetTy Visit(PTR(OMPClause) S)
Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc.
Class that handles pre-initialization statement for some clauses, like 'shedule', 'firstprivate' etc.
This is a basic class for representing single OpenMP clause.
This represents 'collapse' clause in the '#pragma omp ...' directive.
This represents 'compare' clause in the '#pragma omp atomic' directive.
This represents clause 'copyin' in the '#pragma omp ...' directives.
static OMPCopyinClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
static OMPCopyprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'default' clause in the '#pragma omp ...' directive.
This represents 'defaultmap' clause in the '#pragma omp ...' directive.
This represents implicit clause 'depend' for the '#pragma omp task' directive.
static OMPDependClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N variables.
This represents implicit clause 'depobj' for the '#pragma omp depobj' directive.
static OMPDepobjClause * CreateEmpty(const ASTContext &C)
Creates an empty clause.
This represents 'destroy' clause in the '#pragma omp depobj' directive or the '#pragma omp interop' d...
This represents 'detach' clause in the '#pragma omp task' directive.
This represents 'device' clause in the '#pragma omp ...' directive.
This represents 'dist_schedule' clause in the '#pragma omp ...' directive.
This represents the 'doacross' clause for the '#pragma omp ordered' directive.
static OMPDoacrossClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N expressions.
This represents 'dynamic_allocators' clause in the '#pragma omp requires' directive.
This represents clause 'exclusive' in the '#pragma omp scan' directive.
static OMPExclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'fail' clause in the '#pragma omp atomic' directive.
This represents 'filter' clause in the '#pragma omp ...' directive.
This represents 'final' clause in the '#pragma omp ...' directive.
This represents clause 'firstprivate' in the '#pragma omp ...' directives.
static OMPFirstprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents implicit clause 'flush' for the '#pragma omp flush' directive.
static OMPFlushClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents clause 'from' in the '#pragma omp ...' directives.
static OMPFromClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
Representation of the 'full' clause of the '#pragma omp unroll' directive.
static OMPFullClause * CreateEmpty(const ASTContext &C)
Build an empty 'full' AST node for deserialization.
This represents 'grainsize' clause in the '#pragma omp ...' directive.
This represents clause 'has_device_ptr' in the '#pragma omp ...' directives.
static OMPHasDeviceAddrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents 'hint' clause in the '#pragma omp ...' directive.
This represents 'if' clause in the '#pragma omp ...' directive.
This represents clause 'in_reduction' in the '#pragma omp task' directives.
static OMPInReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents clause 'inclusive' in the '#pragma omp scan' directive.
static OMPInclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents the 'init' clause in '#pragma omp ...' directives.
static OMPInitClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N expressions.
This represents clause 'is_device_ptr' in the '#pragma omp ...' directives.
static OMPIsDevicePtrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'lastprivate' in the '#pragma omp ...' directives.
static OMPLastprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents clause 'linear' in the '#pragma omp ...' directives.
static OMPLinearClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
This represents clause 'map' in the '#pragma omp ...' directives.
static OMPMapClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars original expressions, NumUniqueDeclarations declar...
This represents 'mergeable' clause in the '#pragma omp ...' directive.
This represents 'message' clause in the '#pragma omp error' directive.
This represents 'nocontext' clause in the '#pragma omp ...' directive.
This represents 'nogroup' clause in the '#pragma omp ...' directive.
This represents clause 'nontemporal' in the '#pragma omp ...' directives.
static OMPNontemporalClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'novariants' clause in the '#pragma omp ...' directive.
This represents 'nowait' clause in the '#pragma omp ...' directive.
This represents 'num_tasks' clause in the '#pragma omp ...' directive.
This represents 'num_teams' clause in the '#pragma omp ...' directive.
This represents 'num_threads' clause in the '#pragma omp ...' directive.
This represents 'order' clause in the '#pragma omp ...' directive.
This represents 'ordered' clause in the '#pragma omp ...' directive.
static OMPOrderedClause * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty clause.
Representation of the 'partial' clause of the '#pragma omp unroll' directive.
static OMPPartialClause * CreateEmpty(const ASTContext &C)
Build an empty 'partial' AST node for deserialization.
This represents 'priority' clause in the '#pragma omp ...' directive.
This represents clause 'private' in the '#pragma omp ...' directives.
static OMPPrivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'proc_bind' clause in the '#pragma omp ...' directive.
This represents 'read' clause in the '#pragma omp atomic' directive.
This represents clause 'reduction' in the '#pragma omp ...' directives.
static OMPReductionClause * CreateEmpty(const ASTContext &C, unsigned N, OpenMPReductionClauseModifier Modifier)
Creates an empty clause with the place for N variables.
This represents 'relaxed' clause in the '#pragma omp atomic' directives.
This represents 'release' clause in the '#pragma omp atomic|flush' directives.
This represents 'reverse_offload' clause in the '#pragma omp requires' directive.
This represents 'simd' clause in the '#pragma omp ...' directive.
This represents 'safelen' clause in the '#pragma omp ...' directive.
This represents 'schedule' clause in the '#pragma omp ...' directive.
This represents 'seq_cst' clause in the '#pragma omp atomic' directive.
This represents 'severity' clause in the '#pragma omp error' directive.
This represents clause 'shared' in the '#pragma omp ...' directives.
static OMPSharedClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'simdlen' clause in the '#pragma omp ...' directive.
This represents the 'sizes' clause in the '#pragma omp tile' directive.
static OMPSizesClause * CreateEmpty(const ASTContext &C, unsigned NumSizes)
Build an empty 'sizes' AST node for deserialization.
This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives.
static OMPTaskReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'thread_limit' clause in the '#pragma omp ...' directive.
This represents 'threads' clause in the '#pragma omp ...' directive.
This represents clause 'to' in the '#pragma omp ...' directives.
static OMPToClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
llvm::SmallVector< OMPTraitSet, 2 > Sets
The outermost level of selector sets.
This represents 'unified_address' clause in the '#pragma omp requires' directive.
This represents 'unified_shared_memory' clause in the '#pragma omp requires' directive.
This represents 'untied' clause in the '#pragma omp ...' directive.
This represents 'update' clause in the '#pragma omp atomic' directive.
static OMPUpdateClause * CreateEmpty(const ASTContext &C, bool IsExtended)
Creates an empty clause with the place for N variables.
This represents the 'use' clause in '#pragma omp ...' directives.
This represents clause 'use_device_addr' in the '#pragma omp ...' directives.
static OMPUseDeviceAddrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'use_device_ptr' in the '#pragma omp ...' directives.
static OMPUseDevicePtrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'uses_allocators' in the '#pragma omp target'-based directives.
static OMPUsesAllocatorsClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N allocators.
This represents 'weak' clause in the '#pragma omp atomic' directives.
This represents 'write' clause in the '#pragma omp atomic' directive.
This represents 'ompx_attribute' clause in a directive that might generate an outlined function.
This represents 'ompx_bare' clause in the '#pragma omp target teams ...' directive.
This represents 'ompx_dyn_cgroup_mem' clause in the '#pragma omp target ...' directive.
method_range methods() const
Represents an ObjC class declaration.
Wrapper for source info for ObjC interfaces.
void setNameLoc(SourceLocation Loc)
void setNameEndLoc(SourceLocation Loc)
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCMethodDecl - Represents an instance or class method declaration.
bool hasBody() const override
Determine whether this method has a body.
Selector getSelector() const
bool isInstanceMethod() const
void setLazyBody(uint64_t Offset)
Wraps an ObjCPointerType with source location information.
void setStarLoc(SourceLocation Loc)
void setTypeArgsRAngleLoc(SourceLocation Loc)
unsigned getNumTypeArgs() const
unsigned getNumProtocols() const
void setTypeArgsLAngleLoc(SourceLocation Loc)
void setTypeArgTInfo(unsigned i, TypeSourceInfo *TInfo)
void setProtocolLAngleLoc(SourceLocation Loc)
void setProtocolRAngleLoc(SourceLocation Loc)
void setHasBaseTypeAsWritten(bool HasBaseType)
void setProtocolLoc(unsigned i, SourceLocation Loc)
Represents an Objective-C protocol declaration.
The basic abstraction for the target Objective-C runtime.
Kind
The basic Objective-C runtimes that we know about.
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
unsigned getNumProtocols() const
void setProtocolLoc(unsigned i, SourceLocation Loc)
void setProtocolLAngleLoc(SourceLocation Loc)
void setProtocolRAngleLoc(SourceLocation Loc)
static OpenACCAsyncClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCAttachClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCAutoClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
This is the base type for all OpenACC Clauses.
static OpenACCCopyClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCopyInClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsReadOnly, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCopyOutClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCreateClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDefaultClause * Create(const ASTContext &C, OpenACCDefaultClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
static OpenACCDevicePtrClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDeviceTypeClause * Create(const ASTContext &C, OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< DeviceTypeArgument > Archs, SourceLocation EndLoc)
static OpenACCFirstPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCIfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
static OpenACCIndependentClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
static OpenACCNoCreateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCNumGangsClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > IntExprs, SourceLocation EndLoc)
static OpenACCNumWorkersClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCPresentClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCReductionClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, OpenACCReductionOperator Operator, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCSelfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
static OpenACCSeqClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
static OpenACCVectorLengthClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCWaitClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef< Expr * > QueueIdExprs, SourceLocation EndLoc)
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
virtual llvm::StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const =0
Returns the serialized AST inside the PCH container Buffer.
ASTReaderListener implementation to validate the information of the PCH file against an initialized P...
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
void setEllipsisLoc(SourceLocation Loc)
void setEllipsisLoc(SourceLocation Loc)
void setRParenLoc(SourceLocation Loc)
void setLParenLoc(SourceLocation Loc)
Represents a parameter to a function.
void setKWLoc(SourceLocation Loc)
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
Base class that describes a preprocessed entity, which may be a preprocessor directive or macro expan...
Iteration over the preprocessed entities.
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::string > MacroIncludes
std::vector< std::string > Includes
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
std::string PCHThroughHeader
If non-empty, the filename used in an #include directive in the primary source file (or command-line ...
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
bool AllowPCHWithDifferentModulesCachePath
When true, a PCH with modules cache path different to the current compilation will not be rejected.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
std::vector< std::pair< std::string, bool > > Macros
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Module * getCurrentModule()
Retrieves the module that we're currently building, if any.
const TargetInfo & getTargetInfo() const
FileManager & getFileManager() const
PreprocessorOptions & getPreprocessorOpts() const
Retrieve the preprocessor options used to initialize this preprocessor.
HeaderSearch & getHeaderSearchInfo() const
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
void setCounterValue(unsigned V)
DiagnosticsEngine & getDiagnostics() const
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Wrapper of type source information for a type with non-trivial direct qualifiers.
The collection of all-type qualifiers we support.
@ FastWidth
The width of the "fast" qualifier mask.
@ FastMask
The fast qualifier mask.
void setAmpAmpLoc(SourceLocation Loc)
Represents a struct/union/class.
Wrapper for source info for record types.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
This table allows us to fully hide how we implement multi-keyword caching.
Selector getNullarySelector(const IdentifierInfo *ID)
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Selector getUnarySelector(const IdentifierInfo *ID)
Smart pointer class that efficiently represents Objective-C method names.
std::pair< iterator, bool > insert(std::pair< Selector, Lists > &&Val)
iterator find(Selector Sel)
llvm::DenseMap< Selector, Lists >::iterator iterator
std::pair< ObjCMethodList, ObjCMethodList > Lists
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Sema - This implements semantic analysis and AST building for C.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
void warnStackExhausted(SourceLocation Loc)
Warn that the stack is nearly exhausted.
IdentifierResolver IdResolver
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
This object establishes a SourceLocationSequence.
Serialized encoding of a sequence of SourceLocations.
Encodes a location in the source.
static SourceLocation getFromRawEncoding(UIntTy Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
SourceLocation getFileLoc(SourceLocation Loc) const
Given Loc, if it is a macro location return the expansion location or the spelling location,...
void setExternalSLocEntrySource(ExternalSLocEntrySource *Source)
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
One instance of this struct is kept for every file loaded or used.
OptionalFileEntryRef ContentsEntry
References the file which the contents were actually loaded from.
std::optional< llvm::MemoryBufferRef > getBufferIfLoaded() const
Return the buffer, only if it has been loaded.
unsigned BufferOverridden
Indicates whether the buffer itself was provided to override the actual file contents.
OptionalFileEntryRef OrigEntry
Reference to the file entry representing this ContentCache.
Information about a FileID, basically just the logical file that it represents and include stack info...
void setHasLineDirectives()
Set the flag that indicates that this FileID has line table entries associated with it.
Stmt - This represents one statement.
DiagnosticStorage * getStorage() const
Retrieve storage for this particular diagnostic.
Wrapper for substituted template type parameters.
Wrapper for substituted template type parameters.
Represents the declaration of a struct/union/class/enum.
TargetOptions & getTargetOpts() const
Retrieve the target options.
Options for controlling the target.
std::string Triple
The name of the target triple to compile for.
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
std::string ABI
If given, the name of the target ABI to use.
std::string TuneCPU
If given, the name of the target CPU to tune code for.
std::string CPU
If given, the name of the target CPU to generate code for.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line.
A convenient class for passing around template argument information.
Location wrapper for a TemplateArgument.
Represents a template argument.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
ArgKind
The kind of template argument we're storing.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
Stores a list of template parameters for a TemplateDecl and its derived classes.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
unsigned getNumArgs() const
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateKeywordLoc(SourceLocation Loc)
void setTemplateNameLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
ArrayRef< TemplateArgument > template_arguments() const
Wrapper for template type parameters.
Token - This structure provides full information about a lexed token.
void setAnnotationEndLoc(SourceLocation L)
void setLength(unsigned Len)
void setKind(tok::TokenKind K)
tok::TokenKind getKind() const
void setLocation(SourceLocation L)
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
void setAnnotationValue(void *val)
void startToken()
Reset all flags to cleared.
void setIdentifierInfo(IdentifierInfo *II)
void setFlag(TokenFlags Flag)
Set the specified flag.
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
void VisitArrayTypeLoc(ArrayTypeLoc)
void VisitFunctionTypeLoc(FunctionTypeLoc)
TypeLocReader(ASTRecordReader &Reader, LocSeq *Seq)
RetTy Visit(TypeLoc TyLoc)
Base wrapper for a particular "section" of type source info.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
void setUnmodifiedTInfo(TypeSourceInfo *TI) const
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
void setNameLoc(SourceLocation Loc)
The base class of the type hierarchy.
const T * getAs() const
Member-template getAs<specific type>'.
Base class for declarations which introduce a typedef-name.
Wrapper for source info for typedefs.
void setLParenLoc(SourceLocation Loc)
void setTypeofLoc(SourceLocation Loc)
void setRParenLoc(SourceLocation Loc)
Wrapper for source info for unresolved typename using decls.
Wrapper for source info for types used via transparent aliases.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
void setNameLoc(SourceLocation Loc)
Captures information about a #pragma weak directive.
Source location and bit offset of a declaration.
A key used when looking up entities by DeclarationName.
unsigned getHash() const
Compute a fingerprint of this key for use in on-disk hash table.
DeclarationNameKey()=default
Information about a module that has been loaded by the ASTReader.
const PPEntityOffset * PreprocessedEntityOffsets
void * IdentifierLookupTable
A pointer to an on-disk hash table of opaque type IdentifierHashTable.
void * SelectorLookupTable
A pointer to an on-disk hash table of opaque type ASTSelectorLookupTable.
std::vector< std::unique_ptr< ModuleFileExtensionReader > > ExtensionReaders
The list of extension readers that are attached to this module file.
SourceLocation DirectImportLoc
The source location where the module was explicitly or implicitly imported in the local translation u...
StringRef Data
The serialized bitstream data for this file.
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID.
ContinuousRangeMap< uint32_t, int, 2 > PreprocessedEntityRemap
Remapping table for preprocessed entity IDs in this module.
int SLocEntryBaseID
The base ID in the source manager's view of this module.
serialization::IdentifierID BaseIdentifierID
Base identifier ID for identifiers local to this module.
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
serialization::TypeID BaseTypeIndex
Base type ID for types local to this module as represented in the global type ID space.
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
uint64_t MacroOffsetsBase
Base file offset for the offsets in MacroOffsets.
const llvm::support::unaligned_uint64_t * InputFileOffsets
Relative offsets for all of the input file entries in the AST file.
std::vector< unsigned > PreloadIdentifierOffsets
Offsets of identifiers that we're going to preload within IdentifierTableData.
unsigned LocalNumIdentifiers
The number of identifiers in this AST file.
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
const unsigned char * IdentifierTableData
Actual data for the on-disk hash table of identifiers.
uint64_t SLocEntryOffsetsBase
Base file offset for the offsets in SLocEntryOffsets.
llvm::BitstreamCursor InputFilesCursor
The cursor to the start of the input-files block.
std::vector< InputFile > InputFilesLoaded
The input files that have been loaded from this AST file.
serialization::SelectorID BaseSelectorID
Base selector ID for selectors local to this module.
llvm::SetVector< ModuleFile * > ImportedBy
List of modules which depend on this module.
const char * HeaderFileInfoTableData
Actual data for the on-disk hash table of header file information.
SourceLocation ImportLoc
The source location where this module was first imported.
const serialization::unaligned_decl_id_t * FileSortedDecls
Array of file-level DeclIDs sorted by file.
const uint32_t * SLocEntryOffsets
Offsets for all of the source location entries in the AST file.
llvm::BitstreamCursor MacroCursor
The cursor to the start of the preprocessor block, which stores all of the macro definitions.
FileID OriginalSourceFileID
The file ID for the original source file that was used to build this AST file.
FileEntryRef File
The file entry for the module file.
std::string ActualOriginalSourceFileName
The actual original source file name that was used to build this AST file.
uint64_t PreprocessorDetailStartOffset
The offset of the start of the preprocessor detail cursor.
std::vector< InputFileInfo > InputFileInfosLoaded
The input file infos that have been loaded from this AST file.
unsigned LocalNumSubmodules
The number of submodules in this module.
SourceLocation FirstLoc
The first source location in this module.
ASTFileSignature ASTBlockHash
The signature of the AST block of the module file, this can be used to unique module files based on A...
uint64_t SourceManagerBlockStartOffset
The bit offset to the start of the SOURCE_MANAGER_BLOCK.
bool DidReadTopLevelSubmodule
Whether the top-level module has been read from the AST file.
std::string OriginalSourceFileName
The original source file name that was used to build the primary AST file, which may have been modifi...
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
bool HasTimestamps
Whether timestamps are included in this module file.
uint64_t InputFilesOffsetBase
Absolute offset of the start of the input-files block.
llvm::BitstreamCursor SLocEntryCursor
Cursor used to read source location entries.
unsigned NumPreprocessedEntities
bool RelocatablePCH
Whether this precompiled header is a relocatable PCH file.
const uint32_t * SelectorOffsets
Offsets into the selector lookup table's data array where each selector resides.
unsigned BaseDeclIndex
Base declaration index in ASTReader for declarations local to this module.
unsigned NumFileSortedDecls
unsigned LocalNumSLocEntries
The number of source location entries in this AST file.
void * HeaderFileInfoTable
The on-disk hash table that contains information about each of the header files.
unsigned Index
The index of this module in the list of modules.
unsigned NumUserInputFiles
llvm::BitstreamCursor Stream
The main bitstream cursor for the main block.
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
uint64_t SizeInBits
The size of this file, in bits.
const UnalignedUInt64 * TypeOffsets
Offset of each type within the bitstream, indexed by the type ID, or the representation of a Type*.
uint64_t GlobalBitOffset
The global bit offset (or base) of this module.
bool StandardCXXModule
Whether this module file is a standard C++ module.
unsigned LocalNumTypes
The number of types in this AST file.
StringRef ModuleOffsetMap
The module offset map data for this file.
const PPSkippedRange * PreprocessedSkippedRangeOffsets
std::string FileName
The file name of the module file.
uint64_t InputFilesValidationTimestamp
If non-zero, specifies the time when we last validated input files.
llvm::BitstreamCursor PreprocessorDetailCursor
The cursor to the start of the (optional) detailed preprocessing record block.
SourceLocation::UIntTy SLocEntryBaseOffset
The base offset in the source manager's view of this module.
std::string ModuleMapPath
const DeclOffset * DeclOffsets
Offset of each declaration within the bitstream, indexed by the declaration ID (-1).
std::string getTimestampFilename() const
uint64_t MacroStartOffset
The offset of the start of the set of defined macros.
ASTFileSignature Signature
The signature of the module file, which may be used instead of the size and modification time to iden...
unsigned LocalNumMacros
The number of macros in this AST file.
unsigned NumPreprocessedSkippedRanges
const unsigned char * SelectorLookupTableData
A pointer to the character data that comprises the selector table.
void dump()
Dump debugging output for this module.
unsigned LocalNumDecls
The number of declarations in this AST file.
unsigned LocalNumHeaderFileInfos
The number of local HeaderFileInfo structures.
llvm::BitVector SearchPathUsage
The bit vector denoting usage of each header search entry (true = used).
unsigned Generation
The generation of which this module file is a part.
const uint32_t * IdentifierOffsets
Offsets into the identifier table data.
ContinuousRangeMap< uint32_t, int, 2 > SelectorRemap
Remapping table for selector IDs in this module.
ContinuousRangeMap< uint32_t, int, 2 > MacroRemap
Remapping table for macro IDs in this module.
const uint32_t * MacroOffsets
Offsets of macros in the preprocessor block.
uint64_t ASTBlockStartOffset
The bit offset of the AST block of this module.
ContinuousRangeMap< uint32_t, int, 2 > SubmoduleRemap
Remapping table for submodule IDs in this module.
llvm::BitVector VFSUsage
The bit vector denoting usage of each VFS entry (true = used).
uint64_t DeclsBlockStartOffset
The offset to the start of the DECLTYPES_BLOCK block.
SmallVector< uint64_t, 8 > PragmaDiagMappings
Diagnostic IDs and their mappings that the user changed.
unsigned BasePreprocessedSkippedRangeID
Base ID for preprocessed skipped ranges local to this module.
unsigned LocalNumSelectors
The number of selectors new to this file.
ModuleKind Kind
The type of this module.
std::string ModuleName
The name of the module.
serialization::MacroID BaseMacroID
Base macro ID for macros local to this module.
SmallVector< uint64_t, 1 > ObjCCategories
The Objective-C category lists for categories known to this module.
std::string BaseDirectory
The base directory of the module.
llvm::SmallVector< ModuleFile *, 16 > TransitiveImports
List of modules which this modules dependent on.
Manages the set of modules loaded by an AST reader.
ModuleFile & getPrimaryModule()
Returns the primary module associated with the manager, that is, the first module loaded.
AddModuleResult
The result of attempting to add a new module.
@ Missing
The module file is missing.
@ OutOfDate
The module file is out-of-date.
@ NewlyLoaded
The module file was just loaded in response to this call.
@ AlreadyLoaded
The module file had already been loaded.
llvm::iterator_range< SmallVectorImpl< ModuleFile * >::const_iterator > pch_modules() const
A range covering the PCH and preamble module files loaded.
ModuleReverseIterator rbegin()
Reverse iterator to traverse all loaded modules.
void visit(llvm::function_ref< bool(ModuleFile &M)> Visitor, llvm::SmallPtrSetImpl< ModuleFile * > *ModuleFilesHit=nullptr)
Visit each of the modules.
unsigned size() const
Number of modules loaded.
Source range/offset of a preprocessed entity.
uint32_t getOffset() const
RawLocEncoding getBegin() const
RawLocEncoding getEnd() const
Source range of a skipped preprocessor region.
RawLocEncoding getBegin() const
RawLocEncoding getEnd() const
unsigned getFactoryBits() const
ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, unsigned PriorGeneration)
ArrayRef< ObjCMethodDecl * > getInstanceMethods() const
Retrieve the instance methods found by this visitor.
ArrayRef< ObjCMethodDecl * > getFactoryMethods() const
Retrieve the instance methods found by this visitor.
bool instanceHasMoreThanOneDecl() const
bool operator()(ModuleFile &M)
bool factoryHasMoreThanOneDecl() const
unsigned getInstanceBits() const
static TypeIdx fromTypeID(TypeID ID)
32 aligned uint64_t in the AST file.
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
static hash_value_type ComputeHash(const internal_key_type &a)
StringRef internal_key_type
static internal_key_type ReadKey(const unsigned char *d, unsigned n)
Class that performs lookup for an identifier stored in an AST file.
IdentifierID ReadIdentifierID(const unsigned char *d)
data_type ReadData(const internal_key_type &k, const unsigned char *d, unsigned DataLen)
Class that performs lookup for a selector's entries in the global method pool stored in an AST file.
internal_key_type ReadKey(const unsigned char *d, unsigned)
data_type ReadData(Selector, const unsigned char *d, unsigned DataLen)
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
static hash_value_type ComputeHash(Selector Sel)
PredefinedTypeIDs
Predefined type IDs.
CtorInitializerType
The different kinds of data that can occur in a CtorInitializer.
const unsigned NUM_PREDEF_TYPE_IDS
The number of predefined type IDs that are reserved for the PREDEF_TYPE_* constants.
const unsigned NumSpecialTypeIDs
The number of special type IDs.
TypeCode
Record codes for each kind of type.
@ PREDEF_TYPE_LONG_ACCUM_ID
The 'long _Accum' type.
@ PREDEF_TYPE_SAMPLER_ID
OpenCL sampler type.
@ PREDEF_TYPE_INT128_ID
The '__int128_t' type.
@ PREDEF_TYPE_CHAR32_ID
The C++ 'char32_t' type.
@ PREDEF_TYPE_SAT_SHORT_ACCUM_ID
The '_Sat short _Accum' type.
@ PREDEF_TYPE_IBM128_ID
The '__ibm128' type.
@ PREDEF_TYPE_SHORT_FRACT_ID
The 'short _Fract' type.
@ PREDEF_TYPE_AUTO_RREF_DEDUCT
The "auto &&" deduction type.
@ PREDEF_TYPE_BOUND_MEMBER
The placeholder type for bound member functions.
@ PREDEF_TYPE_LONGLONG_ID
The (signed) 'long long' type.
@ PREDEF_TYPE_FRACT_ID
The '_Fract' type.
@ PREDEF_TYPE_ARC_UNBRIDGED_CAST
ARC's unbridged-cast placeholder type.
@ PREDEF_TYPE_USHORT_FRACT_ID
The 'unsigned short _Fract' type.
@ PREDEF_TYPE_SAT_ULONG_FRACT_ID
The '_Sat unsigned long _Fract' type.
@ PREDEF_TYPE_BOOL_ID
The 'bool' or '_Bool' type.
@ PREDEF_TYPE_SAT_LONG_ACCUM_ID
The '_Sat long _Accum' type.
@ PREDEF_TYPE_SAT_LONG_FRACT_ID
The '_Sat long _Fract' type.
@ PREDEF_TYPE_SAT_SHORT_FRACT_ID
The '_Sat short _Fract' type.
@ PREDEF_TYPE_CHAR_U_ID
The 'char' type, when it is unsigned.
@ PREDEF_TYPE_RESERVE_ID_ID
OpenCL reserve_id type.
@ PREDEF_TYPE_SAT_ACCUM_ID
The '_Sat _Accum' type.
@ PREDEF_TYPE_BUILTIN_FN
The placeholder type for builtin functions.
@ PREDEF_TYPE_SHORT_ACCUM_ID
The 'short _Accum' type.
@ PREDEF_TYPE_FLOAT_ID
The 'float' type.
@ PREDEF_TYPE_QUEUE_ID
OpenCL queue type.
@ PREDEF_TYPE_INT_ID
The (signed) 'int' type.
@ PREDEF_TYPE_OBJC_SEL
The ObjC 'SEL' type.
@ PREDEF_TYPE_BFLOAT16_ID
The '__bf16' type.
@ PREDEF_TYPE_WCHAR_ID
The C++ 'wchar_t' type.
@ PREDEF_TYPE_UCHAR_ID
The 'unsigned char' type.
@ PREDEF_TYPE_UACCUM_ID
The 'unsigned _Accum' type.
@ PREDEF_TYPE_SCHAR_ID
The 'signed char' type.
@ PREDEF_TYPE_CHAR_S_ID
The 'char' type, when it is signed.
@ PREDEF_TYPE_NULLPTR_ID
The type of 'nullptr'.
@ PREDEF_TYPE_ULONG_FRACT_ID
The 'unsigned long _Fract' type.
@ PREDEF_TYPE_FLOAT16_ID
The '_Float16' type.
@ PREDEF_TYPE_UINT_ID
The 'unsigned int' type.
@ PREDEF_TYPE_FLOAT128_ID
The '__float128' type.
@ PREDEF_TYPE_OBJC_ID
The ObjC 'id' type.
@ PREDEF_TYPE_CHAR16_ID
The C++ 'char16_t' type.
@ PREDEF_TYPE_ARRAY_SECTION
The placeholder type for an array section.
@ PREDEF_TYPE_ULONGLONG_ID
The 'unsigned long long' type.
@ PREDEF_TYPE_SAT_UFRACT_ID
The '_Sat unsigned _Fract' type.
@ PREDEF_TYPE_USHORT_ID
The 'unsigned short' type.
@ PREDEF_TYPE_SHORT_ID
The (signed) 'short' type.
@ PREDEF_TYPE_OMP_ARRAY_SHAPING
The placeholder type for OpenMP array shaping operation.
@ PREDEF_TYPE_DEPENDENT_ID
The placeholder type for dependent types.
@ PREDEF_TYPE_LONGDOUBLE_ID
The 'long double' type.
@ PREDEF_TYPE_DOUBLE_ID
The 'double' type.
@ PREDEF_TYPE_UINT128_ID
The '__uint128_t' type.
@ PREDEF_TYPE_HALF_ID
The OpenCL 'half' / ARM NEON __fp16 type.
@ PREDEF_TYPE_VOID_ID
The void type.
@ PREDEF_TYPE_SAT_USHORT_FRACT_ID
The '_Sat unsigned short _Fract' type.
@ PREDEF_TYPE_ACCUM_ID
The '_Accum' type.
@ PREDEF_TYPE_SAT_FRACT_ID
The '_Sat _Fract' type.
@ PREDEF_TYPE_NULL_ID
The NULL type.
@ PREDEF_TYPE_USHORT_ACCUM_ID
The 'unsigned short _Accum' type.
@ PREDEF_TYPE_CHAR8_ID
The C++ 'char8_t' type.
@ PREDEF_TYPE_UFRACT_ID
The 'unsigned _Fract' type.
@ PREDEF_TYPE_OVERLOAD_ID
The placeholder type for overloaded function sets.
@ PREDEF_TYPE_INCOMPLETE_MATRIX_IDX
A placeholder type for incomplete matrix index operations.
@ PREDEF_TYPE_UNRESOLVED_TEMPLATE
The placeholder type for unresolved templates.
@ PREDEF_TYPE_SAT_USHORT_ACCUM_ID
The '_Sat unsigned short _Accum' type.
@ PREDEF_TYPE_LONG_ID
The (signed) 'long' type.
@ PREDEF_TYPE_SAT_ULONG_ACCUM_ID
The '_Sat unsigned long _Accum' type.
@ PREDEF_TYPE_LONG_FRACT_ID
The 'long _Fract' type.
@ PREDEF_TYPE_UNKNOWN_ANY
The 'unknown any' placeholder type.
@ PREDEF_TYPE_OMP_ITERATOR
The placeholder type for OpenMP iterator expression.
@ PREDEF_TYPE_PSEUDO_OBJECT
The pseudo-object placeholder type.
@ PREDEF_TYPE_OBJC_CLASS
The ObjC 'Class' type.
@ PREDEF_TYPE_ULONG_ID
The 'unsigned long' type.
@ PREDEF_TYPE_SAT_UACCUM_ID
The '_Sat unsigned _Accum' type.
@ PREDEF_TYPE_CLK_EVENT_ID
OpenCL clk event type.
@ PREDEF_TYPE_EVENT_ID
OpenCL event type.
@ PREDEF_TYPE_ULONG_ACCUM_ID
The 'unsigned long _Accum' type.
@ PREDEF_TYPE_AUTO_DEDUCT
The "auto" deduction type.
@ CTOR_INITIALIZER_MEMBER
@ CTOR_INITIALIZER_DELEGATING
@ CTOR_INITIALIZER_INDIRECT_MEMBER
@ DECL_CXX_BASE_SPECIFIERS
A record containing CXXBaseSpecifiers.
@ DECL_CONTEXT_LEXICAL
A record that stores the set of declarations that are lexically stored within a given DeclContext.
@ DECL_CXX_CTOR_INITIALIZERS
A record containing CXXCtorInitializers.
@ DECL_CONTEXT_VISIBLE
A record that stores the set of declarations that are visible from a given DeclContext.
@ TYPE_EXT_QUAL
An ExtQualType record.
@ SPECIAL_TYPE_OBJC_SEL_REDEFINITION
Objective-C "SEL" redefinition type.
@ SPECIAL_TYPE_UCONTEXT_T
C ucontext_t typedef type.
@ SPECIAL_TYPE_JMP_BUF
C jmp_buf typedef type.
@ SPECIAL_TYPE_FILE
C FILE typedef type.
@ SPECIAL_TYPE_SIGJMP_BUF
C sigjmp_buf typedef type.
@ SPECIAL_TYPE_OBJC_CLASS_REDEFINITION
Objective-C "Class" redefinition type.
@ SPECIAL_TYPE_CF_CONSTANT_STRING
CFConstantString type.
@ SPECIAL_TYPE_OBJC_ID_REDEFINITION
Objective-C "id" redefinition type.
Defines the clang::TargetInfo interface.
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing),...
@ Warning
Present this diagnostic as a warning.
@ Error
Present this diagnostic as an error.
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
llvm::OnDiskChainedHashTable< HeaderFileInfoTrait > HeaderFileInfoLookupTable
The on-disk hash table used for known header files.
llvm::OnDiskIterableChainedHashTable< ASTIdentifierLookupTrait > ASTIdentifierLookupTable
The on-disk hash table used to contain information about all of the identifiers in the program.
llvm::OnDiskChainedHashTable< ASTSelectorLookupTrait > ASTSelectorLookupTable
The on-disk hash table used for the global method pool.
uint64_t TypeID
An ID number that refers to a type in an AST file.
@ EXTENSION_METADATA
Metadata describing this particular extension.
llvm::support::detail::packed_endian_specific_integral< serialization::DeclID, llvm::endianness::native, llvm::support::unaligned > unaligned_decl_id_t
@ SUBMODULE_EXCLUDED_HEADER
Specifies a header that has been explicitly excluded from this submodule.
@ SUBMODULE_TOPHEADER
Specifies a top-level header that falls into this (sub)module.
@ SUBMODULE_PRIVATE_TEXTUAL_HEADER
Specifies a header that is private to this submodule but must be textually included.
@ SUBMODULE_HEADER
Specifies a header that falls into this (sub)module.
@ SUBMODULE_EXPORT_AS
Specifies the name of the module that will eventually re-export the entities in this module.
@ SUBMODULE_UMBRELLA_DIR
Specifies an umbrella directory.
@ SUBMODULE_UMBRELLA_HEADER
Specifies the umbrella header used to create this module, if any.
@ SUBMODULE_METADATA
Metadata for submodules as a whole.
@ SUBMODULE_REQUIRES
Specifies a required feature.
@ SUBMODULE_PRIVATE_HEADER
Specifies a header that is private to this submodule.
@ SUBMODULE_IMPORTS
Specifies the submodules that are imported by this submodule.
@ SUBMODULE_CONFLICT
Specifies a conflict with another module.
@ SUBMODULE_INITIALIZERS
Specifies some declarations with initializers that must be emitted to initialize the module.
@ SUBMODULE_DEFINITION
Defines the major attributes of a submodule, including its name and parent.
@ SUBMODULE_LINK_LIBRARY
Specifies a library or framework to link against.
@ SUBMODULE_CONFIG_MACRO
Specifies a configuration macro for this module.
@ SUBMODULE_EXPORTS
Specifies the submodules that are re-exported from this submodule.
@ SUBMODULE_TEXTUAL_HEADER
Specifies a header that is part of the module but must be textually included.
@ SUBMODULE_AFFECTING_MODULES
Specifies affecting modules that were not imported.
TypeID LocalTypeID
Same with TypeID except that the LocalTypeID is only meaningful with the corresponding ModuleFile.
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
OptionsRecordTypes
Record types that occur within the options block inside the control block.
@ FILE_SYSTEM_OPTIONS
Record code for the filesystem options table.
@ TARGET_OPTIONS
Record code for the target options table.
@ PREPROCESSOR_OPTIONS
Record code for the preprocessor options table.
@ HEADER_SEARCH_OPTIONS
Record code for the headers search options table.
@ LANGUAGE_OPTIONS
Record code for the language options table.
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
@ SUBMODULE_BLOCK_ID
The block containing the submodule structure.
@ PREPROCESSOR_DETAIL_BLOCK_ID
The block containing the detailed preprocessing record.
@ AST_BLOCK_ID
The AST block, which acts as a container around the full AST block.
@ SOURCE_MANAGER_BLOCK_ID
The block containing information about the source manager.
@ CONTROL_BLOCK_ID
The control block, which contains all of the information that needs to be validated prior to committi...
@ DECLTYPES_BLOCK_ID
The block containing the definitions of all of the types and decls used within the AST file.
@ PREPROCESSOR_BLOCK_ID
The block containing information about the preprocessor.
@ COMMENTS_BLOCK_ID
The block containing comments.
@ UNHASHED_CONTROL_BLOCK_ID
A block with unhashed content.
@ EXTENSION_BLOCK_ID
A block containing a module file extension.
@ OPTIONS_BLOCK_ID
The block of configuration options, used to check that a module is being used in a configuration comp...
@ INPUT_FILES_BLOCK_ID
The block of input files, which were used as inputs to create this AST file.
CommentRecordTypes
Record types used within a comments block.
@ SM_SLOC_FILE_ENTRY
Describes a source location entry (SLocEntry) for a file.
@ SM_SLOC_BUFFER_BLOB_COMPRESSED
Describes a zlib-compressed blob that contains the data for a buffer entry.
@ SM_SLOC_BUFFER_ENTRY
Describes a source location entry (SLocEntry) for a buffer.
@ SM_SLOC_BUFFER_BLOB
Describes a blob that contains the data for a buffer entry.
@ SM_SLOC_EXPANSION_ENTRY
Describes a source location entry (SLocEntry) for a macro expansion.
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
DeclIDBase::DeclID DeclID
An ID number that refers to a declaration in an AST file.
PreprocessorRecordTypes
Record types used within a preprocessor block.
@ PP_TOKEN
Describes one token.
@ PP_MACRO_FUNCTION_LIKE
A function-like macro definition.
@ PP_MACRO_OBJECT_LIKE
An object-like macro definition.
@ PP_MACRO_DIRECTIVE_HISTORY
The macro directives history for a particular identifier.
@ PP_MODULE_MACRO
A macro directive exported by a module.
ControlRecordTypes
Record types that occur within the control block.
@ MODULE_MAP_FILE
Record code for the module map file that was used to build this AST file.
@ MODULE_DIRECTORY
Record code for the module build directory.
@ IMPORTS
Record code for the list of other AST files imported by this AST file.
@ ORIGINAL_FILE_ID
Record code for file ID of the file or buffer that was used to generate the AST file.
@ MODULE_NAME
Record code for the module name.
@ ORIGINAL_FILE
Record code for the original file that was used to generate the AST file, including both its file ID ...
@ INPUT_FILE_OFFSETS
Offsets into the input-files block where input files reside.
@ METADATA
AST file metadata, including the AST file version number and information about the compiler used to b...
UnhashedControlBlockRecordTypes
Record codes for the unhashed control block.
@ DIAGNOSTIC_OPTIONS
Record code for the diagnostic options table.
@ HEADER_SEARCH_ENTRY_USAGE
Record code for the indices of used header search entries.
@ AST_BLOCK_HASH
Record code for the content hash of the AST block.
@ DIAG_PRAGMA_MAPPINGS
Record code for #pragma diagnostic mappings.
@ SIGNATURE
Record code for the signature that identifiers this AST file.
@ HEADER_SEARCH_PATHS
Record code for the headers search paths.
@ VFS_USAGE
Record code for the indices of used VFSs.
InputFileRecordTypes
Record types that occur within the input-files block inside the control block.
@ INPUT_FILE_HASH
The input file content hash.
@ INPUT_FILE
An input file.
PreprocessorDetailRecordTypes
Record types used within a preprocessor detail block.
@ PPD_INCLUSION_DIRECTIVE
Describes an inclusion directive within the preprocessing record.
@ PPD_MACRO_EXPANSION
Describes a macro expansion within the preprocessing record.
@ PPD_MACRO_DEFINITION
Describes a macro definition within the preprocessing record.
ModuleKind
Specifies the kind of module that has been loaded.
@ MK_PCH
File is a PCH file treated as such.
@ MK_Preamble
File is a PCH file treated as the preamble.
@ MK_MainFile
File is a PCH file treated as the actual main file.
@ MK_ExplicitModule
File is an explicitly-loaded module.
@ MK_ImplicitModule
File is an implicitly-loaded module.
@ MK_PrebuiltModule
File is from a prebuilt module path.
uint64_t IdentifierID
An ID number that refers to an identifier in an AST file.
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
ASTRecordTypes
Record types that occur within the AST block itself.
@ DECL_UPDATE_OFFSETS
Record for offsets of DECL_UPDATES records for declarations that were modified after being deserializ...
@ STATISTICS
Record code for the extra statistics we gather while generating an AST file.
@ FLOAT_CONTROL_PRAGMA_OPTIONS
Record code for #pragma float_control options.
@ KNOWN_NAMESPACES
Record code for the set of known namespaces, which are used for typo correction.
@ SPECIAL_TYPES
Record code for the set of non-builtin, special types.
@ PENDING_IMPLICIT_INSTANTIATIONS
Record code for pending implicit instantiations.
@ TYPE_OFFSET
Record code for the offsets of each type.
@ DELEGATING_CTORS
The list of delegating constructor declarations.
@ PP_ASSUME_NONNULL_LOC
ID 66 used to be the list of included files.
@ EXT_VECTOR_DECLS
Record code for the set of ext_vector type names.
@ OPENCL_EXTENSIONS
Record code for enabled OpenCL extensions.
@ FP_PRAGMA_OPTIONS
Record code for floating point #pragma options.
@ PP_UNSAFE_BUFFER_USAGE
Record code for #pragma clang unsafe_buffer_usage begin/end.
@ VTABLE_USES
Record code for the array of VTable uses.
@ LATE_PARSED_TEMPLATE
Record code for late parsed template functions.
@ DECLS_TO_CHECK_FOR_DEFERRED_DIAGS
Record code for the Decls to be checked for deferred diags.
@ DECL_OFFSET
Record code for the offsets of each decl.
@ SOURCE_MANAGER_LINE_TABLE
Record code for the source manager line table information, which stores information about #line direc...
@ PP_COUNTER_VALUE
The value of the next COUNTER to dispense.
@ DELETE_EXPRS_TO_ANALYZE
Delete expressions that will be analyzed later.
@ UPDATE_VISIBLE
Record code for an update to a decl context's lookup table.
@ CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH
Number of unmatched #pragma clang cuda_force_host_device begin directives we've seen.
@ MACRO_OFFSET
Record code for the table of offsets of each macro ID.
@ PPD_ENTITIES_OFFSETS
Record code for the table of offsets to entries in the preprocessing record.
@ IDENTIFIER_OFFSET
Record code for the table of offsets of each identifier ID.
@ OBJC_CATEGORIES
Record code for the array of Objective-C categories (including extensions).
@ METHOD_POOL
Record code for the Objective-C method pool,.
@ DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD
Record code for lexical and visible block for delayed namespace in reduced BMI.
@ PP_CONDITIONAL_STACK
The stack of open #ifs/#ifdefs recorded in a preamble.
@ REFERENCED_SELECTOR_POOL
Record code for referenced selector pool.
@ SOURCE_LOCATION_OFFSETS
Record code for the table of offsets into the block of source-location information.
@ WEAK_UNDECLARED_IDENTIFIERS
Record code for weak undeclared identifiers.
@ UNDEFINED_BUT_USED
Record code for undefined but used functions and variables that need a definition in this TU.
@ FILE_SORTED_DECLS
Record code for a file sorted array of DeclIDs in a module.
@ MSSTRUCT_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
@ TENTATIVE_DEFINITIONS
Record code for the array of tentative definitions.
@ UNUSED_FILESCOPED_DECLS
Record code for the array of unused file scoped decls.
@ ALIGN_PACK_PRAGMA_OPTIONS
Record code for #pragma align/pack options.
@ IMPORTED_MODULES
Record code for an array of all of the (sub)modules that were imported by the AST file.
@ SELECTOR_OFFSETS
Record code for the table of offsets into the Objective-C method pool.
@ UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES
Record code for potentially unused local typedef names.
@ EAGERLY_DESERIALIZED_DECLS
Record code for the array of eagerly deserialized decls.
@ INTERESTING_IDENTIFIERS
A list of "interesting" identifiers.
@ HEADER_SEARCH_TABLE
Record code for header search information.
@ OBJC_CATEGORIES_MAP
Record code for map of Objective-C class definition IDs to the ObjC categories in a module that are a...
@ CUDA_SPECIAL_DECL_REFS
Record code for special CUDA declarations.
@ TU_UPDATE_LEXICAL
Record code for an update to the TU's lexically contained declarations.
@ PPD_SKIPPED_RANGES
A table of skipped ranges within the preprocessing record.
@ IDENTIFIER_TABLE
Record code for the identifier table.
@ SEMA_DECL_REFS
Record code for declarations that Sema keeps references of.
@ OPTIMIZE_PRAGMA_OPTIONS
Record code for #pragma optimize options.
@ MODULE_OFFSET_MAP
Record code for the remapping information used to relate loaded modules to the various offsets and ID...
@ POINTERS_TO_MEMBERS_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
uint32_t MacroID
An ID number that refers to a macro in an AST file.
unsigned ComputeHash(Selector Sel)
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
OpenACCClauseKind
Represents the kind of an OpenACC clause.
@ Auto
'auto' clause, allowed on 'loop' directives.
@ Bind
'bind' clause, allowed on routine constructs.
@ Gang
'gang' clause, allowed on 'loop' and Combined constructs.
@ Wait
'wait' clause, allowed on Compute, Data, 'update', and Combined constructs.
@ DevicePtr
'deviceptr' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ PCopyOut
'copyout' clause alias 'pcopyout'. Preserved for diagnostic purposes.
@ VectorLength
'vector_length' clause, allowed on 'parallel', 'kernels', 'parallel loop', and 'kernels loop' constru...
@ Async
'async' clause, allowed on Compute, Data, 'update', 'wait', and Combined constructs.
@ PresentOrCreate
'create' clause alias 'present_or_create'.
@ Collapse
'collapse' clause, allowed on 'loop' and Combined constructs.
@ NoHost
'nohost' clause, allowed on 'routine' directives.
@ PresentOrCopy
'copy' clause alias 'present_or_copy'. Preserved for diagnostic purposes.
@ DeviceNum
'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
@ Invalid
Represents an invalid clause, for the purposes of parsing.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Copy
'copy' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ Worker
'worker' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ DeviceType
'device_type' clause, allowed on Compute, 'data', 'init', 'shutdown', 'set', update',...
@ DefaultAsync
'default_async' clause, allowed on 'set' construct.
@ Attach
'attach' clause, allowed on Compute and Combined constructs, plus 'data' and 'enter data'.
@ NumGangs
'num_gangs' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs.
@ If
'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...
@ Default
'default' clause, allowed on parallel, serial, kernel (and compound) constructs.
@ UseDevice
'use_device' clause, allowed on 'host_data' construct.
@ NoCreate
'no_create' clause, allowed on allowed on Compute and Combined constructs, plus 'data'.
@ PresentOrCopyOut
'copyout' clause alias 'present_or_copyout'.
@ Link
'link' clause, allowed on 'declare' construct.
@ Reduction
'reduction' clause, allowed on Parallel, Serial, Loop, and the combined constructs.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ CopyOut
'copyout' clause, allowed on Compute and Combined constructs, plus 'data', 'exit data',...
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ FirstPrivate
'firstprivate' clause, allowed on 'parallel', 'serial', 'parallel loop', and 'serial loop' constructs...
@ Host
'host' clause, allowed on 'update' construct.
@ PCopy
'copy' clause alias 'pcopy'. Preserved for diagnostic purposes.
@ Tile
'tile' clause, allowed on 'loop' and Combined constructs.
@ PCopyIn
'copyin' clause alias 'pcopyin'. Preserved for diagnostic purposes.
@ DeviceResident
'device_resident' clause, allowed on the 'declare' construct.
@ PCreate
'create' clause alias 'pcreate'. Preserved for diagnostic purposes.
@ Present
'present' clause, allowed on Compute and Combined constructs, plus 'data' and 'declare'.
@ DType
'dtype' clause, an alias for 'device_type', stored separately for diagnostic purposes.
@ CopyIn
'copyin' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ Device
'device' clause, allowed on the 'update' construct.
@ Independent
'independent' clause, allowed on 'loop' directives.
@ NumWorkers
'num_workers' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs...
@ IfPresent
'if_present' clause, allowed on 'host_data' and 'update' directives.
@ Detach
'detach' clause, allowed on the 'exit data' construct.
@ Delete
'delete' clause, allowed on the 'exit data' construct.
@ PresentOrCopyIn
'copyin' clause alias 'present_or_copyin'.
@ Finalize
'finalize' clause, allowed on 'exit data' directive.
TypeSpecifierType
Specifies the kind of type.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
OpenMPDefaultmapClauseModifier
OpenMP modifiers for 'defaultmap' clause.
OpenMPOrderClauseModifier
OpenMP modifiers for 'order' clause.
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
OpenMPAtClauseKind
OpenMP attributes for 'at' clause.
OpenMPReductionClauseModifier
OpenMP modifiers for 'reduction' clause.
OpenMPScheduleClauseModifier
OpenMP modifiers for 'schedule' clause.
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
OpenMPDoacrossClauseModifier
OpenMP dependence types for 'doacross' clause.
static constexpr unsigned NumberOfOMPMapClauseModifiers
Number of allowed map-type-modifiers.
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
PredefinedDeclIDs
Predefined declaration IDs.
@ PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID
The internal '__NSConstantString' tag type.
@ PREDEF_DECL_TRANSLATION_UNIT_ID
The translation unit.
@ PREDEF_DECL_TYPE_PACK_ELEMENT_ID
The internal '__type_pack_element' template.
@ PREDEF_DECL_OBJC_CLASS_ID
The Objective-C 'Class' type.
@ PREDEF_DECL_BUILTIN_MS_GUID_ID
The predeclared '_GUID' struct.
@ PREDEF_DECL_OBJC_INSTANCETYPE_ID
The internal 'instancetype' typedef.
@ PREDEF_DECL_OBJC_PROTOCOL_ID
The Objective-C 'Protocol' type.
@ PREDEF_DECL_UNSIGNED_INT_128_ID
The unsigned 128-bit integer type.
@ PREDEF_DECL_OBJC_SEL_ID
The Objective-C 'SEL' type.
@ PREDEF_DECL_INT_128_ID
The signed 128-bit integer type.
@ PREDEF_DECL_VA_LIST_TAG
The internal '__va_list_tag' struct, if any.
@ PREDEF_DECL_BUILTIN_MS_VA_LIST_ID
The internal '__builtin_ms_va_list' typedef.
@ PREDEF_DECL_CF_CONSTANT_STRING_ID
The internal '__NSConstantString' typedef.
@ PREDEF_DECL_NULL_ID
The NULL declaration.
@ PREDEF_DECL_BUILTIN_VA_LIST_ID
The internal '__builtin_va_list' typedef.
@ PREDEF_DECL_EXTERN_C_CONTEXT_ID
The extern "C" context.
@ PREDEF_DECL_OBJC_ID_ID
The Objective-C 'id' type.
@ PREDEF_DECL_MAKE_INTEGER_SEQ_ID
The internal '__make_integer_seq' template.
@ Property
The type of a property.
@ Result
The result type of a method or function.
OpenMPBindClauseKind
OpenMP bindings for the 'bind' clause.
OpenMPLastprivateModifier
OpenMP 'lastprivate' clause modifier.
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
OpenMPGrainsizeClauseModifier
OpenMPNumTasksClauseModifier
OpenMPSeverityClauseKind
OpenMP attributes for 'severity' clause.
static constexpr unsigned NumberOfOMPMotionModifiers
Number of allowed motion-modifiers.
TypeSpecifierWidth
Specifies the width of a type, e.g., short, long, or long long.
OpenMPMotionModifierKind
OpenMP modifier kind for 'to' or 'from' clause.
OpenMPDefaultmapClauseKind
OpenMP attributes for 'defaultmap' clause.
OpenMPLinearClauseKind
OpenMP attributes for 'linear' clause.
TypeSpecifierSign
Specifies the signedness of a type, e.g., signed or unsigned.
const FunctionProtoType * T
DisableValidationForModuleKind
Whether to disable the normal validation performed on precompiled headers and module files when they ...
@ None
Perform validation, don't disable it.
@ PCH
Disable validation for a precompiled header and the modules it depends on.
@ Module
Disable validation for module files.
bool shouldSkipCheckingODR(const Decl *D)
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
OpenMPAtomicDefaultMemOrderClauseKind
OpenMP attributes for 'atomic_default_mem_order' clause.
@ Success
Template argument deduction was successful.
U cast(CodeGen::Address addr)
@ None
The alignment was not explicit in code.
OpenMPDeviceClauseModifier
OpenMP modifiers for 'device' clause.
OpenMPMapModifierKind
OpenMP modifier kind for 'map' clause.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
OpenMPOrderClauseKind
OpenMP attributes for 'order' clause.
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
OpenMPMapClauseKind
OpenMP mapping kind for 'map' clause.
The signature of a module, which is a hash of the AST content.
static constexpr size_t size
static ASTFileSignature create(std::array< uint8_t, 20 > Bytes)
static ASTFileSignature createDummy()
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setInfo(const DeclarationNameLoc &Info)
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
A simple structure that captures a vtable use for the purposes of the ExternalSemaSource.
ExceptionSpecInfo ExceptionSpec
static LineEntry get(unsigned Offs, unsigned Line, int Filename, SrcMgr::CharacteristicKind FileKind, unsigned IncludeOffset)
A conflict between two modules.
Module * Other
The module that this module conflicts with.
std::string Message
The message provided to the user when there is a conflict.
A library or framework to link against when an entity from this module is used.
This structure contains all sizes needed for by an OMPMappableExprListClause.
unsigned NumComponentLists
Number of component lists.
unsigned NumVars
Number of expressions listed.
unsigned NumUniqueDeclarations
Number of unique base declarations.
unsigned NumComponents
Total number of expression components.
Data for list of allocators.
a linked list of methods with the same selector name but different signatures.
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
TemplateParameterList ** TemplParamLists
A new-allocated array of size NumTemplParamLists, containing pointers to the "outer" template paramet...
NestedNameSpecifierLoc QualifierLoc
unsigned NumTemplParamLists
The number of "outer" template parameter lists.
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
SanitizerMask Mask
Bitmask of enabled sanitizers.
Helper class that saves the current stream position and then restores it when destroyed.
PragmaMsStackAction Action
Location information for a TemplateArgument.
Describes the categories of an Objective-C class.
void insert(GlobalDeclID ID)