91#include "llvm/ADT/APFloat.h"
92#include "llvm/ADT/APInt.h"
93#include "llvm/ADT/APSInt.h"
94#include "llvm/ADT/ArrayRef.h"
95#include "llvm/ADT/DenseMap.h"
96#include "llvm/ADT/FloatingPointMode.h"
97#include "llvm/ADT/FoldingSet.h"
98#include "llvm/ADT/Hashing.h"
99#include "llvm/ADT/IntrusiveRefCntPtr.h"
100#include "llvm/ADT/STLExtras.h"
101#include "llvm/ADT/ScopeExit.h"
102#include "llvm/ADT/SmallPtrSet.h"
103#include "llvm/ADT/SmallString.h"
104#include "llvm/ADT/SmallVector.h"
105#include "llvm/ADT/StringExtras.h"
106#include "llvm/ADT/StringMap.h"
107#include "llvm/ADT/StringRef.h"
108#include "llvm/ADT/iterator_range.h"
109#include "llvm/Bitstream/BitstreamReader.h"
110#include "llvm/Support/Casting.h"
111#include "llvm/Support/Compiler.h"
112#include "llvm/Support/Compression.h"
113#include "llvm/Support/DJB.h"
114#include "llvm/Support/Endian.h"
115#include "llvm/Support/Error.h"
116#include "llvm/Support/ErrorHandling.h"
117#include "llvm/Support/FileSystem.h"
118#include "llvm/Support/LEB128.h"
119#include "llvm/Support/MemoryBuffer.h"
120#include "llvm/Support/Path.h"
121#include "llvm/Support/SaveAndRestore.h"
122#include "llvm/Support/TimeProfiler.h"
123#include "llvm/Support/Timer.h"
124#include "llvm/Support/VersionTuple.h"
125#include "llvm/Support/raw_ostream.h"
126#include "llvm/TargetParser/Triple.h"
139#include <system_error>
144using namespace clang;
147using llvm::BitstreamCursor;
155 return First->ReadFullVersionInformation(FullVersion) ||
156 Second->ReadFullVersionInformation(FullVersion);
160 First->ReadModuleName(ModuleName);
161 Second->ReadModuleName(ModuleName);
165 First->ReadModuleMapFile(ModuleMapPath);
166 Second->ReadModuleMapFile(ModuleMapPath);
172 bool AllowCompatibleDifferences) {
173 return First->ReadLanguageOptions(LangOpts, Complain,
174 AllowCompatibleDifferences) ||
175 Second->ReadLanguageOptions(LangOpts, Complain,
176 AllowCompatibleDifferences);
181 bool AllowCompatibleDifferences) {
182 return First->ReadTargetOptions(TargetOpts, Complain,
183 AllowCompatibleDifferences) ||
184 Second->ReadTargetOptions(TargetOpts, Complain,
185 AllowCompatibleDifferences);
190 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
191 Second->ReadDiagnosticOptions(DiagOpts, Complain);
197 return First->ReadFileSystemOptions(FSOpts, Complain) ||
198 Second->ReadFileSystemOptions(FSOpts, Complain);
204 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
206 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
212 std::string &SuggestedPredefines) {
213 return First->ReadPreprocessorOptions(PPOpts, Complain,
214 SuggestedPredefines) ||
215 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
220 First->ReadCounter(M,
Value);
221 Second->ReadCounter(M,
Value);
225 return First->needsInputFileVisitation() ||
226 Second->needsInputFileVisitation();
230 return First->needsSystemInputFileVisitation() ||
231 Second->needsSystemInputFileVisitation();
236 First->visitModuleFile(
Filename, Kind);
237 Second->visitModuleFile(
Filename, Kind);
243 bool isExplicitModule) {
244 bool Continue =
false;
245 if (First->needsInputFileVisitation() &&
246 (!isSystem || First->needsSystemInputFileVisitation()))
247 Continue |= First->visitInputFile(
Filename, isSystem, isOverridden,
249 if (Second->needsInputFileVisitation() &&
250 (!isSystem || Second->needsSystemInputFileVisitation()))
251 Continue |= Second->visitInputFile(
Filename, isSystem, isOverridden,
258 First->readModuleFileExtension(Metadata);
259 Second->readModuleFileExtension(Metadata);
279 bool AllowCompatibleDifferences =
true) {
280#define LANGOPT(Name, Bits, Default, Description) \
281 if (ExistingLangOpts.Name != LangOpts.Name) { \
283 Diags->Report(diag::err_pch_langopt_mismatch) \
284 << Description << LangOpts.Name << ExistingLangOpts.Name; \
288#define VALUE_LANGOPT(Name, Bits, Default, Description) \
289 if (ExistingLangOpts.Name != LangOpts.Name) { \
291 Diags->Report(diag::err_pch_langopt_value_mismatch) \
296#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
297 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
299 Diags->Report(diag::err_pch_langopt_value_mismatch) \
304#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
305 if (!AllowCompatibleDifferences) \
306 LANGOPT(Name, Bits, Default, Description)
308#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
309 if (!AllowCompatibleDifferences) \
310 ENUM_LANGOPT(Name, Bits, Default, Description)
312#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
313 if (!AllowCompatibleDifferences) \
314 VALUE_LANGOPT(Name, Bits, Default, Description)
316#define BENIGN_LANGOPT(Name, Bits, Default, Description)
317#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
318#define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description)
319#include "clang/Basic/LangOptions.def"
323 Diags->
Report(diag::err_pch_langopt_value_mismatch) <<
"module features";
329 Diags->
Report(diag::err_pch_langopt_value_mismatch)
330 <<
"target Objective-C runtime";
337 Diags->
Report(diag::err_pch_langopt_value_mismatch)
338 <<
"block command names";
346 if (!AllowCompatibleDifferences) {
350 ExistingSanitizers.
clear(ModularSanitizers);
351 ImportedSanitizers.
clear(ModularSanitizers);
352 if (ExistingSanitizers.
Mask != ImportedSanitizers.
Mask) {
353 const std::string Flag =
"-fsanitize=";
355#define SANITIZER(NAME, ID) \
357 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
358 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
359 if (InExistingModule != InImportedModule) \
360 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
361 << InExistingModule << (Flag + NAME); \
363#include "clang/Basic/Sanitizers.def"
381 bool AllowCompatibleDifferences =
true) {
382#define CHECK_TARGET_OPT(Field, Name) \
383 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
385 Diags->Report(diag::err_pch_targetopt_mismatch) \
386 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
397 if (!AllowCompatibleDifferences) {
402#undef CHECK_TARGET_OPT
410 llvm::sort(ExistingFeatures);
411 llvm::sort(ReadFeatures);
417 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
418 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
419 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
420 ExistingFeatures.begin(), ExistingFeatures.end(),
421 std::back_inserter(UnmatchedReadFeatures));
425 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
429 for (StringRef Feature : UnmatchedReadFeatures)
430 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
432 for (StringRef Feature : UnmatchedExistingFeatures)
433 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
437 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
443 bool AllowCompatibleDifferences) {
446 Complain ? &Reader.Diags :
nullptr,
447 AllowCompatibleDifferences);
452 bool AllowCompatibleDifferences) {
455 Complain ? &Reader.Diags :
nullptr,
456 AllowCompatibleDifferences);
461using MacroDefinitionsMap =
462 llvm::StringMap<std::pair<StringRef,
bool >>;
463using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
478 for (
auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
487 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror=" +
506 bool IsSystem,
bool Complain) {
514 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Wsystem-headers";
521 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror";
528 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Weverything -Werror";
535 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-pedantic-errors";
559 assert(!ModuleName.empty() &&
"diagnostic options read before module name");
563 assert(M &&
"missing module");
578 assert(ModuleMgr.
size() >= 1 &&
"what ASTFile is this then");
594 MacroDefinitionsMap &Macros,
596 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
597 StringRef Macro = PPOpts.
Macros[I].first;
598 bool IsUndef = PPOpts.
Macros[I].second;
600 std::pair<StringRef, StringRef> MacroPair = Macro.split(
'=');
601 StringRef MacroName = MacroPair.first;
602 StringRef MacroBody = MacroPair.second;
606 if (MacroNames && !Macros.count(MacroName))
607 MacroNames->push_back(MacroName);
609 Macros[MacroName] = std::make_pair(
"",
true);
614 if (MacroName.size() == Macro.size())
618 StringRef::size_type End = MacroBody.find_first_of(
"\n\r");
619 MacroBody = MacroBody.substr(0, End);
622 if (MacroNames && !Macros.count(MacroName))
623 MacroNames->push_back(MacroName);
624 Macros[MacroName] = std::make_pair(MacroBody,
false);
647 FileManager &FileMgr, std::string &SuggestedPredefines,
651 MacroDefinitionsMap ASTFileMacros;
653 MacroDefinitionsMap ExistingMacros;
657 for (
unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
659 StringRef MacroName = ExistingMacroNames[I];
660 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
663 llvm::StringMap<std::pair<StringRef,
bool >>::iterator Known =
664 ASTFileMacros.find(MacroName);
670 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
true;
678 if (Existing.second) {
679 SuggestedPredefines +=
"#undef ";
680 SuggestedPredefines += MacroName.str();
681 SuggestedPredefines +=
'\n';
683 SuggestedPredefines +=
"#define ";
684 SuggestedPredefines += MacroName.str();
685 SuggestedPredefines +=
' ';
686 SuggestedPredefines += Existing.first.str();
687 SuggestedPredefines +=
'\n';
694 if (Existing.second != Known->second.second) {
696 Diags->
Report(diag::err_pch_macro_def_undef)
697 << MacroName << Known->second.second;
704 if (Existing.second || Existing.first == Known->second.first) {
705 ASTFileMacros.erase(Known);
711 Diags->
Report(diag::err_pch_macro_def_conflict)
712 << MacroName << Known->second.first << Existing.first;
719 for (
const auto &MacroName : ASTFileMacros.keys()) {
721 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
false;
737 if (LangOpts.Modules &&
747 for (
unsigned I = 0, N = ExistingPPOpts.
Includes.size(); I != N; ++I) {
754 SuggestedPredefines +=
"#include \"";
755 SuggestedPredefines +=
File;
756 SuggestedPredefines +=
"\"\n";
766 SuggestedPredefines +=
"#include \"";
767 SuggestedPredefines +=
File;
768 SuggestedPredefines +=
"\"\n";
771 for (
unsigned I = 0, N = ExistingPPOpts.
MacroIncludes.size(); I != N; ++I) {
776 SuggestedPredefines +=
"#__include_macros \"";
777 SuggestedPredefines +=
File;
778 SuggestedPredefines +=
"\"\n##\n";
786 std::string &SuggestedPredefines) {
790 Complain? &Reader.Diags :
nullptr,
799 std::string &SuggestedPredefines) {
810 StringRef SpecificModuleCachePath,
811 StringRef ExistingModuleCachePath,
815 if (LangOpts.Modules) {
816 if (SpecificModuleCachePath != ExistingModuleCachePath &&
819 Diags->
Report(diag::err_pch_modulecache_mismatch)
820 << SpecificModuleCachePath << ExistingModuleCachePath;
829 StringRef SpecificModuleCachePath,
833 Complain ? &Reader.Diags :
nullptr,
847 const char *
Error =
nullptr;
849 uint64_t Val = llvm::decodeULEB128(
P, &Length,
nullptr, &
Error);
851 llvm::report_fatal_error(
Error);
857static std::pair<unsigned, unsigned>
860 if ((
unsigned)KeyLen != KeyLen)
861 llvm::report_fatal_error(
"key too large");
864 if ((
unsigned)DataLen != DataLen)
865 llvm::report_fatal_error(
"data too large");
867 return std::make_pair(KeyLen, DataLen);
871 bool TakeOwnership) {
872 DeserializationListener = Listener;
873 OwnsDeserializationListener = TakeOwnership;
880std::pair<unsigned, unsigned>
887 using namespace llvm::support;
890 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
892 F, endian::readNext<uint32_t, little, unaligned>(d));
899 Args.push_back(FirstII);
900 for (
unsigned I = 1; I != N; ++I)
901 Args.push_back(Reader.getLocalIdentifier(
902 F, endian::readNext<uint32_t, little, unaligned>(d)));
910 using namespace llvm::support;
914 Result.ID = Reader.getGlobalSelectorID(
915 F, endian::readNext<uint32_t, little, unaligned>(d));
916 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
917 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
918 Result.InstanceBits = FullInstanceBits & 0x3;
919 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
920 Result.FactoryBits = FullFactoryBits & 0x3;
921 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
922 unsigned NumInstanceMethods = FullInstanceBits >> 3;
923 unsigned NumFactoryMethods = FullFactoryBits >> 3;
926 for (
unsigned I = 0; I != NumInstanceMethods; ++I) {
928 F, endian::readNext<uint32_t, little, unaligned>(d)))
929 Result.Instance.push_back(Method);
933 for (
unsigned I = 0; I != NumFactoryMethods; ++I) {
935 F, endian::readNext<uint32_t, little, unaligned>(d)))
936 Result.Factory.push_back(Method);
943 return llvm::djbHash(a);
946std::pair<unsigned, unsigned>
953 assert(n >= 2 && d[n-1] ==
'\0');
954 return StringRef((
const char*) d, n-1);
968 bool Value = Bits & 0x1;
974 using namespace llvm::support;
976 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
977 return Reader.getGlobalIdentifierID(F, RawID >> 1);
990 const unsigned char* d,
992 using namespace llvm::support;
994 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
995 bool IsInteresting = RawID & 0x01;
1003 II = &Reader.getIdentifierTable().getOwn(k);
1007 Reader.markIdentifierUpToDate(II);
1009 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
1010 if (!IsInteresting) {
1013 Reader.SetIdentifierInfo(ID, II);
1017 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
1018 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
1019 bool CPlusPlusOperatorKeyword =
readBit(Bits);
1020 bool HasRevertedTokenIDToIdentifier =
readBit(Bits);
1021 bool Poisoned =
readBit(Bits);
1022 bool ExtensionToken =
readBit(Bits);
1023 bool HadMacroDefinition =
readBit(Bits);
1025 assert(Bits == 0 &&
"Extra bits in the identifier?");
1030 if (HasRevertedTokenIDToIdentifier && II->
getTokenID() != tok::identifier)
1035 "Incorrect extension token flag");
1036 (void)ExtensionToken;
1040 "Incorrect C++ operator keyword flag");
1041 (void)CPlusPlusOperatorKeyword;
1045 if (HadMacroDefinition) {
1046 uint32_t MacroDirectivesOffset =
1047 endian::readNext<uint32_t, little, unaligned>(d);
1050 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1053 Reader.SetIdentifierInfo(ID, II);
1059 for (; DataLen > 0; DataLen -= 4)
1060 DeclIDs.push_back(Reader.getGlobalDeclID(
1061 F, endian::readNext<uint32_t, little, unaligned>(d)));
1062 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1069 : Kind(Name.getNameKind()) {
1072 Data = (uint64_t)Name.getAsIdentifierInfo();
1077 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1080 Data = Name.getCXXOverloadedOperator();
1083 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1086 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1087 ->getDeclName().getAsIdentifierInfo();
1099 llvm::FoldingSetNodeID ID;
1100 ID.AddInteger(Kind);
1123 return ID.ComputeHash();
1127ASTDeclContextNameLookupTrait::ReadFileRef(
const unsigned char *&d) {
1128 using namespace llvm::support;
1130 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1131 return Reader.getLocalModuleFile(F, ModuleFileID);
1134std::pair<unsigned, unsigned>
1135ASTDeclContextNameLookupTrait::ReadKeyDataLength(
const unsigned char *&d) {
1140ASTDeclContextNameLookupTrait::ReadKey(
const unsigned char *d,
unsigned) {
1141 using namespace llvm::support;
1149 Data = (uint64_t)Reader.getLocalIdentifier(
1150 F, endian::readNext<uint32_t, little, unaligned>(d));
1156 (uint64_t)Reader.getLocalSelector(
1157 F, endian::readNext<uint32_t, little, unaligned>(
1158 d)).getAsOpaquePtr();
1175 const unsigned char *d,
1178 using namespace llvm::support;
1180 for (
unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1181 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1182 Val.
insert(Reader.getGlobalDeclID(F, LocalID));
1186bool ASTReader::ReadLexicalDeclContextStorage(
ModuleFile &M,
1187 BitstreamCursor &Cursor,
1193 if (llvm::Error Err = Cursor.JumpToBit(
Offset)) {
1194 Error(std::move(Err));
1202 Error(MaybeCode.takeError());
1205 unsigned Code = MaybeCode.get();
1208 if (!MaybeRecCode) {
1209 Error(MaybeRecCode.takeError());
1212 unsigned RecCode = MaybeRecCode.get();
1214 Error(
"Expected lexical block");
1218 assert(!isa<TranslationUnitDecl>(DC) &&
1219 "expected a TU_UPDATE_LEXICAL record for TU");
1224 auto &Lex = LexicalDecls[DC];
1226 Lex = std::make_pair(
1228 reinterpret_cast<const llvm::support::unaligned_uint32_t *
>(
1236bool ASTReader::ReadVisibleDeclContextStorage(
ModuleFile &M,
1237 BitstreamCursor &Cursor,
1244 Error(std::move(Err));
1252 Error(MaybeCode.takeError());
1255 unsigned Code = MaybeCode.get();
1258 if (!MaybeRecCode) {
1259 Error(MaybeRecCode.takeError());
1262 unsigned RecCode = MaybeRecCode.get();
1264 Error(
"Expected visible lookup table block");
1270 auto *
Data = (
const unsigned char*)Blob.data();
1271 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&M,
Data});
1275void ASTReader::Error(StringRef Msg)
const {
1276 Error(diag::err_fe_pch_malformed, Msg);
1277 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1278 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1279 Diag(diag::note_module_cache_path)
1280 << PP.getHeaderSearchInfo().getModuleCachePath();
1284void ASTReader::Error(
unsigned DiagID, StringRef Arg1, StringRef Arg2,
1285 StringRef Arg3)
const {
1286 if (Diags.isDiagnosticInFlight())
1287 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1289 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1292void ASTReader::Error(llvm::Error &&Err)
const {
1293 llvm::Error RemainingErr =
1300 assert(NumArgs <= 3 &&
"Can only have up to 3 arguments");
1301 StringRef Arg1, Arg2, Arg3;
1304 Arg3 =
Diag.getStringArg(2);
1307 Arg2 =
Diag.getStringArg(1);
1310 Arg1 =
Diag.getStringArg(0);
1312 Error(
Diag.getDiagID(), Arg1, Arg2, Arg3);
1323void ASTReader::ParseLineTable(
ModuleFile &F,
const RecordData &Record) {
1328 std::map<int, int> FileIDs;
1330 for (
unsigned I = 0;
Record[Idx]; ++I) {
1332 auto Filename = ReadPath(F, Record, Idx);
1338 std::vector<LineEntry> Entries;
1339 while (Idx <
Record.size()) {
1340 FileID FID = ReadFileID(F, Record, Idx);
1343 unsigned NumEntries =
Record[Idx++];
1344 assert(NumEntries &&
"no line entries for file ID");
1346 Entries.reserve(NumEntries);
1347 for (
unsigned I = 0; I != NumEntries; ++I) {
1348 unsigned FileOffset =
Record[Idx++];
1349 unsigned LineNo =
Record[Idx++];
1350 int FilenameID = FileIDs[
Record[Idx++]];
1353 unsigned IncludeOffset =
Record[Idx++];
1355 FileKind, IncludeOffset));
1362llvm::Error ASTReader::ReadSourceManagerBlock(
ModuleFile &F) {
1363 using namespace SrcMgr;
1371 SLocEntryCursor = F.
Stream;
1374 if (llvm::Error Err = F.
Stream.SkipBlock())
1385 SLocEntryCursor.advanceSkippingSubblocks();
1387 return MaybeE.takeError();
1388 llvm::BitstreamEntry E = MaybeE.get();
1391 case llvm::BitstreamEntry::SubBlock:
1392 case llvm::BitstreamEntry::Error:
1393 return llvm::createStringError(std::errc::illegal_byte_sequence,
1394 "malformed block record in AST file");
1395 case llvm::BitstreamEntry::EndBlock:
1396 return llvm::Error::success();
1397 case llvm::BitstreamEntry::Record:
1406 SLocEntryCursor.readRecord(E.ID, Record, &Blob);
1408 return MaybeRecord.takeError();
1409 switch (MaybeRecord.get()) {
1417 return llvm::Error::success();
1426 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1427 Error(
"source location entry ID out-of-range for AST file");
1433 auto ReadBuffer = [
this](
1434 BitstreamCursor &SLocEntryCursor,
1435 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1440 Error(MaybeCode.takeError());
1443 unsigned Code = MaybeCode.get();
1446 SLocEntryCursor.readRecord(Code, Record, &Blob);
1447 if (!MaybeRecCode) {
1448 Error(MaybeRecCode.takeError());
1451 unsigned RecCode = MaybeRecCode.get();
1456 const llvm::compression::Format F =
1457 Blob.size() > 0 && Blob.data()[0] == 0x78
1458 ? llvm::compression::Format::Zlib
1459 : llvm::compression::Format::Zstd;
1460 if (
const char *Reason = llvm::compression::getReasonIfUnsupported(F)) {
1465 if (llvm::Error E = llvm::compression::decompress(
1466 F, llvm::arrayRefFromStringRef(Blob), Decompressed, Record[0])) {
1467 Error(
"could not decompress embedded file contents: " +
1468 llvm::toString(std::move(E)));
1471 return llvm::MemoryBuffer::getMemBufferCopy(
1472 llvm::toStringRef(Decompressed), Name);
1474 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name,
true);
1476 Error(
"AST record has invalid code");
1481 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1485 Error(std::move(Err));
1492 ++NumSLocEntriesRead;
1495 Error(MaybeEntry.takeError());
1498 llvm::BitstreamEntry Entry = MaybeEntry.get();
1500 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1501 Error(
"incorrectly-formatted source location entry in AST file");
1508 SLocEntryCursor.readRecord(Entry.ID, Record, &Blob);
1510 Error(MaybeSLOC.takeError());
1513 switch (MaybeSLOC.get()) {
1515 Error(
"incorrectly-formatted source location entry in AST file");
1521 unsigned InputID = Record[4];
1522 InputFile IF = getInputFile(*F, InputID);
1535 IncludeLoc = getImportLocation(F);
1539 FileID FID = SourceMgr.createFileID(*
File, IncludeLoc, FileCharacter, ID,
1540 BaseOffset + Record[0]);
1543 FileInfo.NumCreatedFIDs = Record[5];
1547 unsigned NumFileDecls = Record[7];
1548 if (NumFileDecls && ContextObj) {
1550 assert(F->
FileSortedDecls &&
"FILE_SORTED_DECLS not encountered yet ?");
1556 SourceMgr.getOrCreateContentCache(*
File, isSystem(FileCharacter));
1560 auto Buffer = ReadBuffer(SLocEntryCursor,
File->getName());
1563 SourceMgr.overrideFileContents(*
File, std::move(Buffer));
1570 const char *Name = Blob.data();
1571 unsigned Offset = Record[0];
1576 IncludeLoc = getImportLocation(F);
1579 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1582 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1583 BaseOffset +
Offset, IncludeLoc);
1589 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1], Seq);
1590 SourceLocation ExpansionBegin = ReadSourceLocation(*F, Record[2], Seq);
1591 SourceLocation ExpansionEnd = ReadSourceLocation(*F, Record[3], Seq);
1592 SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
1593 Record[5], Record[4], ID,
1594 BaseOffset + Record[0]);
1606 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1607 Error(
"source location entry ID out-of-range for AST file");
1612 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1630 assert(SourceMgr.getMainFileID().isValid() &&
"missing main file");
1631 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1641 uint64_t *StartOfBlockOffset) {
1642 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID))
1645 if (StartOfBlockOffset)
1646 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1649 uint64_t
Offset = Cursor.GetCurrentBitNo();
1652 return MaybeCode.takeError();
1653 unsigned Code = MaybeCode.get();
1656 if (Code != llvm::bitc::DEFINE_ABBREV) {
1657 if (llvm::Error Err = Cursor.JumpToBit(
Offset))
1659 return llvm::Error::success();
1661 if (llvm::Error Err = Cursor.ReadAbbrevRecord())
1670 Tok.
setLocation(ReadSourceLocation(F, Record, Idx));
1677 case tok::annot_pragma_loop_hint: {
1679 Info->
PragmaName = ReadToken(F, Record, Idx);
1680 Info->Option = ReadToken(F, Record, Idx);
1681 unsigned NumTokens = Record[Idx++];
1683 Toks.reserve(NumTokens);
1684 for (
unsigned I = 0; I < NumTokens; ++I)
1685 Toks.push_back(ReadToken(F, Record, Idx));
1686 Info->Toks =
llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
1690 case tok::annot_pragma_pack: {
1693 auto SlotLabel = ReadString(Record, Idx);
1695 llvm::StringRef(SlotLabel).copy(PP.getPreprocessorAllocator());
1696 Info->Alignment = ReadToken(F, Record, Idx);
1701 case tok::annot_pragma_openmp:
1702 case tok::annot_pragma_openmp_end:
1703 case tok::annot_pragma_unused:
1706 llvm_unreachable(
"missing deserialization code for annotation token");
1723 if (llvm::Error Err = Stream.JumpToBit(
Offset)) {
1725 consumeError(std::move(Err));
1737 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1739 Stream.advanceSkippingSubblocks(Flags);
1741 Error(MaybeEntry.takeError());
1744 llvm::BitstreamEntry Entry = MaybeEntry.get();
1746 switch (Entry.Kind) {
1747 case llvm::BitstreamEntry::SubBlock:
1748 case llvm::BitstreamEntry::Error:
1749 Error(
"malformed block record in AST file");
1751 case llvm::BitstreamEntry::EndBlock:
1753 case llvm::BitstreamEntry::Record:
1764 Error(MaybeRecType.takeError());
1780 unsigned NextIndex = 1;
1782 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1787 PP.getPreprocessorAllocator());
1790 bool isC99VarArgs = Record[NextIndex++];
1791 bool isGNUVarArgs = Record[NextIndex++];
1792 bool hasCommaPasting = Record[NextIndex++];
1793 MacroParams.clear();
1794 unsigned NumArgs = Record[NextIndex++];
1795 for (
unsigned i = 0; i != NumArgs; ++i)
1796 MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1810 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1811 Record[NextIndex]) {
1814 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1816 PreprocessingRecord::PPEntityID PPID =
1817 PPRec.getPPEntityID(GlobalID - 1,
true);
1819 PPRec.getPreprocessedEntity(PPID));
1821 PPRec.RegisterMacroDefinition(Macro, PPDef);
1832 if (MacroTokens.empty()) {
1833 Error(
"unexpected number of macro tokens for a macro in AST file");
1838 MacroTokens[0] = ReadToken(F, Record, Idx);
1839 MacroTokens = MacroTokens.drop_front();
1848 unsigned LocalID)
const {
1850 ReadModuleOffsetMap(M);
1855 &&
"Invalid index into preprocessed entity index remap");
1857 return LocalID + I->second;
1861 return llvm::hash_combine(ikey.
Size, ikey.
ModTime);
1882 if (!Key.Imported) {
1888 std::string Resolved = std::string(Key.Filename);
1889 Reader.ResolveImportedPath(M, Resolved);
1897 return FEA && FEA == FEB;
1900std::pair<unsigned, unsigned>
1901HeaderFileInfoTrait::ReadKeyDataLength(
const unsigned char*& d) {
1906HeaderFileInfoTrait::ReadKey(
const unsigned char *d,
unsigned) {
1907 using namespace llvm::support;
1910 ikey.
Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1911 ikey.
ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1920 using namespace llvm::support;
1922 const unsigned char *End = d + DataLen;
1924 unsigned Flags = *d++;
1926 HFI.
isImport |= (Flags >> 5) & 0x01;
1928 HFI.
DirInfo = (Flags >> 1) & 0x07;
1931 M, endian::readNext<uint32_t, little, unaligned>(d));
1932 if (
unsigned FrameworkOffset =
1933 endian::readNext<uint32_t, little, unaligned>(d)) {
1936 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1937 HFI.
Framework = HS->getUniqueFrameworkName(FrameworkName);
1940 assert((End - d) % 4 == 0 &&
1941 "Wrong data length in HeaderFileInfo deserialization");
1943 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1949 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1950 Module *Mod = Reader.getSubmodule(GlobalSMID);
1953 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1957 Reader.ResolveImportedPath(M,
Filename);
1961 ModMap.
addHeader(Mod, H, HeaderRole,
true);
1972 uint32_t MacroDirectivesOffset) {
1973 assert(NumCurrentElementsDeserializing > 0 &&
"Missing deserialization guard");
1974 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1981 for (
ModuleFile &I : llvm::reverse(ModuleMgr)) {
1982 BitstreamCursor &MacroCursor = I.MacroCursor;
1985 if (MacroCursor.getBitcodeBytes().empty())
1988 BitstreamCursor Cursor = MacroCursor;
1989 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
1990 Error(std::move(Err));
1998 Error(MaybeE.takeError());
2001 llvm::BitstreamEntry E = MaybeE.get();
2004 case llvm::BitstreamEntry::SubBlock:
2005 case llvm::BitstreamEntry::Error:
2006 Error(
"malformed block record in AST file");
2008 case llvm::BitstreamEntry::EndBlock:
2011 case llvm::BitstreamEntry::Record: {
2015 Error(MaybeRecord.takeError());
2018 switch (MaybeRecord.get()) {
2026 updateOutOfDateIdentifier(*II);
2045 class IdentifierLookupVisitor {
2048 unsigned PriorGeneration;
2049 unsigned &NumIdentifierLookups;
2050 unsigned &NumIdentifierLookupHits;
2054 IdentifierLookupVisitor(StringRef Name,
unsigned PriorGeneration,
2055 unsigned &NumIdentifierLookups,
2056 unsigned &NumIdentifierLookupHits)
2058 PriorGeneration(PriorGeneration),
2059 NumIdentifierLookups(NumIdentifierLookups),
2060 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2074 ++NumIdentifierLookups;
2075 ASTIdentifierLookupTable::iterator Pos =
2076 IdTable->find_hashed(Name, NameHash, &Trait);
2077 if (Pos == IdTable->end())
2083 ++NumIdentifierLookupHits;
2099 unsigned PriorGeneration = 0;
2100 if (getContext().getLangOpts().Modules)
2101 PriorGeneration = IdentifierGeneration[&II];
2107 if (!loadGlobalIndex()) {
2108 if (GlobalIndex->lookupIdentifier(II.
getName(), Hits)) {
2113 IdentifierLookupVisitor Visitor(II.
getName(), PriorGeneration,
2114 NumIdentifierLookups,
2115 NumIdentifierLookupHits);
2116 ModuleMgr.visit(Visitor, HitsPtr);
2117 markIdentifierUpToDate(&II);
2127 if (getContext().getLangOpts().Modules)
2128 IdentifierGeneration[II] = getGeneration();
2132 const PendingMacroInfo &PMInfo) {
2137 if (llvm::Error Err =
2139 Error(std::move(Err));
2143 struct ModuleMacroRecord {
2156 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2158 Error(MaybeEntry.takeError());
2161 llvm::BitstreamEntry Entry = MaybeEntry.get();
2163 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2164 Error(
"malformed block record in AST file");
2171 Error(MaybePP.takeError());
2179 ModuleMacros.push_back(ModuleMacroRecord());
2180 auto &Info = ModuleMacros.back();
2181 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
2182 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
2183 for (
int I = 2, N = Record.size(); I != N; ++I)
2184 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2189 Error(
"malformed block record in AST file");
2200 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2202 for (
auto &MMR : ModuleMacros) {
2204 for (
unsigned ModID : MMR.Overrides) {
2205 Module *Mod = getSubmodule(ModID);
2206 auto *Macro = PP.getModuleMacro(Mod, II);
2207 assert(Macro &&
"missing definition for overridden macro");
2208 Overrides.push_back(Macro);
2211 bool Inserted =
false;
2212 Module *Owner = getSubmodule(MMR.SubModID);
2213 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2224 unsigned Idx = 0, N = Record.size();
2231 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2232 MD = PP.AllocateDefMacroDirective(MI, Loc);
2236 MD = PP.AllocateUndefMacroDirective(Loc);
2239 bool isPublic = Record[Idx++];
2240 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2252 PP.setLoadedMacroDirective(II, Earliest, Latest);
2255bool ASTReader::shouldDisableValidationForFile(
2292 consumeError(std::move(Err));
2298 consumeError(MaybeCode.takeError());
2300 unsigned Code = MaybeCode.get();
2306 "invalid record type for input file");
2309 consumeError(Maybe.takeError());
2312 assert(Record[0] == ID &&
"Bogus stored ID or offset");
2320 ResolveImportedPath(F, R.
Filename);
2324 consumeError(MaybeEntry.takeError());
2325 llvm::BitstreamEntry Entry = MaybeEntry.get();
2326 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2327 "expected record type for input file hash");
2332 "invalid record type for input file hash");
2335 consumeError(Maybe.takeError());
2363 consumeError(std::move(Err));
2375 expectedToOptional(FileMgr.getFileRef(
Filename,
false)));
2379 if ((Overridden || Transient) && !
File)
2380 File = FileMgr.getVirtualFileRef(
Filename, StoredSize, StoredTime);
2384 std::string ErrorStr =
"could not find file '";
2386 ErrorStr +=
"' referenced by AST file '";
2402 if ((!Overridden && !Transient) &&
SM.isFileOverridden(
File)) {
2416 enum ModificationKind {
2422 std::optional<int64_t> Old = std::nullopt;
2423 std::optional<int64_t> New = std::nullopt;
2425 auto HasInputFileChanged = [&]() {
2426 if (StoredSize !=
File->getSize())
2427 return Change{Change::Size, StoredSize,
File->getSize()};
2428 if (!shouldDisableValidationForFile(F) && StoredTime &&
2429 StoredTime !=
File->getModificationTime()) {
2430 Change MTimeChange = {Change::ModTime, StoredTime,
2431 File->getModificationTime()};
2435 if (ValidateASTInputFilesContent &&
2436 StoredContentHash !=
static_cast<uint64_t>(llvm::hash_code(-1))) {
2437 auto MemBuffOrError = FileMgr.getBufferForFile(
File);
2438 if (!MemBuffOrError) {
2441 std::string ErrorStr =
"could not get buffer for file '";
2442 ErrorStr +=
File->getName();
2449 auto ContentHash =
hash_value(MemBuffOrError.get()->getBuffer());
2450 if (StoredContentHash ==
static_cast<uint64_t>(ContentHash))
2451 return Change{Change::None};
2453 return Change{Change::Content};
2457 return Change{Change::None};
2460 bool IsOutOfDate =
false;
2461 auto FileChange = HasInputFileChanged();
2463 if (!Overridden && FileChange.Kind != Change::None) {
2464 if (Complain && !Diags.isDiagnosticInFlight()) {
2467 while (!ImportStack.back()->ImportedBy.empty())
2468 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2471 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2472 Diag(diag::err_fe_ast_file_modified)
2474 << TopLevelPCHName << FileChange.Kind
2475 << (FileChange.Old && FileChange.New)
2476 << llvm::itostr(FileChange.Old.value_or(0))
2477 << llvm::itostr(FileChange.New.value_or(0));
2480 if (ImportStack.size() > 1) {
2481 Diag(diag::note_pch_required_by)
2482 <<
Filename << ImportStack[0]->FileName;
2483 for (
unsigned I = 1; I < ImportStack.size(); ++I)
2484 Diag(diag::note_pch_required_by)
2485 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2488 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2517 llvm::sys::path::append(Buffer, Prefix,
Filename);
2518 Filename.assign(Buffer.begin(), Buffer.end());
2533 llvm_unreachable(
"unknown ASTReadResult");
2537 BitstreamCursor &Stream,
unsigned ClientLoadCapabilities,
2539 std::string &SuggestedPredefines) {
2542 consumeError(std::move(Err));
2553 consumeError(MaybeEntry.takeError());
2556 llvm::BitstreamEntry Entry = MaybeEntry.get();
2558 switch (Entry.Kind) {
2559 case llvm::BitstreamEntry::Error:
2560 case llvm::BitstreamEntry::SubBlock:
2563 case llvm::BitstreamEntry::EndBlock:
2566 case llvm::BitstreamEntry::Record:
2574 if (!MaybeRecordType) {
2576 consumeError(MaybeRecordType.takeError());
2581 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2582 if (ParseLanguageOptions(Record, Complain, Listener,
2583 AllowCompatibleConfigurationMismatch))
2584 Result = ConfigurationMismatch;
2589 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2590 if (ParseTargetOptions(Record, Complain, Listener,
2591 AllowCompatibleConfigurationMismatch))
2592 Result = ConfigurationMismatch;
2597 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2598 if (!AllowCompatibleConfigurationMismatch &&
2599 ParseFileSystemOptions(Record, Complain, Listener))
2600 Result = ConfigurationMismatch;
2605 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2606 if (!AllowCompatibleConfigurationMismatch &&
2607 ParseHeaderSearchOptions(Record, Complain, Listener))
2608 Result = ConfigurationMismatch;
2613 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2614 if (!AllowCompatibleConfigurationMismatch &&
2615 ParsePreprocessorOptions(Record, Complain, Listener,
2616 SuggestedPredefines))
2617 Result = ConfigurationMismatch;
2627 unsigned ClientLoadCapabilities) {
2628 BitstreamCursor &Stream = F.
Stream;
2631 Error(std::move(Err));
2641 bool HasReadUnhashedControlBlock =
false;
2642 auto readUnhashedControlBlockOnce = [&]() {
2643 if (!HasReadUnhashedControlBlock) {
2644 HasReadUnhashedControlBlock =
true;
2645 if (ASTReadResult
Result =
2646 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2652 bool DisableValidation = shouldDisableValidationForFile(F);
2656 unsigned NumInputs = 0;
2657 unsigned NumUserInputs = 0;
2658 StringRef BaseDirectoryAsWritten;
2662 Error(MaybeEntry.takeError());
2665 llvm::BitstreamEntry Entry = MaybeEntry.get();
2667 switch (Entry.Kind) {
2668 case llvm::BitstreamEntry::Error:
2669 Error(
"malformed block record in AST file");
2671 case llvm::BitstreamEntry::EndBlock: {
2674 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2679 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2686 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2692 unsigned N = ValidateSystemInputs ? NumInputs : NumUserInputs;
2698 for (
unsigned I = 0; I < N; ++I) {
2699 InputFile IF = getInputFile(F, I+1, Complain);
2711 for (
unsigned I = 0; I < N; ++I) {
2712 bool IsSystem = I >= NumUserInputs;
2723 case llvm::BitstreamEntry::SubBlock:
2727 if (llvm::Error Err = Stream.SkipBlock()) {
2728 Error(std::move(Err));
2732 Error(
"malformed block record in AST file");
2741 if (Listener && !ImportedBy) {
2747 bool AllowCompatibleConfigurationMismatch =
2751 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2752 AllowCompatibleConfigurationMismatch, *Listener,
2753 SuggestedPredefines);
2755 Error(
"malformed block record in AST file");
2759 if (DisableValidation ||
2760 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
2768 }
else if (llvm::Error Err = Stream.SkipBlock()) {
2769 Error(std::move(Err));
2775 if (llvm::Error Err = Stream.SkipBlock()) {
2776 Error(std::move(Err));
2782 case llvm::BitstreamEntry::Record:
2791 Stream.readRecord(Entry.ID, Record, &Blob);
2792 if (!MaybeRecordType) {
2793 Error(MaybeRecordType.takeError());
2799 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2801 : diag::err_pch_version_too_new);
2805 bool hasErrors =
Record[6];
2806 if (hasErrors && !DisableValidation) {
2809 if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
2810 canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
2813 if (!AllowASTWithCompilerErrors) {
2814 Diag(diag::err_pch_with_compiler_errors);
2819 Diags.ErrorOccurred =
true;
2820 Diags.UncompilableErrorOccurred =
true;
2821 Diags.UnrecoverableErrorOccurred =
true;
2832 StringRef ASTBranch = Blob;
2833 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2834 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2835 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2845 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2849 unsigned Idx = 0, N =
Record.size();
2857 ReadUntranslatedSourceLocation(Record[Idx++]);
2858 off_t StoredSize = (off_t)Record[Idx++];
2859 time_t StoredModTime = (time_t)Record[Idx++];
2860 auto FirstSignatureByte =
Record.begin() + Idx;
2865 std::string ImportedName = ReadString(Record, Idx);
2866 std::string ImportedFile;
2874 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2875 ImportedName,
true);
2877 if (ImportedFile.empty())
2880 ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2882 SkipPath(Record, Idx);
2886 unsigned Capabilities = ClientLoadCapabilities;
2887 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2888 Capabilities &= ~ARR_Missing;
2891 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2892 Loaded, StoredSize, StoredModTime,
2893 StoredSignature, Capabilities);
2896 bool recompilingFinalized =
2897 Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
2898 getModuleManager().getModuleCache().isPCMFinal(F.
FileName);
2900 Diag(diag::note_module_file_imported_by)
2902 if (recompilingFinalized)
2903 Diag(diag::note_module_file_conflict);
2906 case Failure:
return Failure;
2909 case OutOfDate:
return OutOfDate;
2911 case ConfigurationMismatch:
return ConfigurationMismatch;
2912 case HadErrors:
return HadErrors;
2932 Diag(diag::remark_module_import)
2934 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
2940 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2948 BaseDirectoryAsWritten = Blob;
2950 "MODULE_DIRECTORY found before MODULE_NAME");
2953 Module *M = PP.getHeaderSearchInfo().lookupModule(
2960 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
2963 auto BuildDir = PP.getFileManager().getDirectory(Blob);
2964 if (!BuildDir || *BuildDir != M->
Directory) {
2965 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
2966 Diag(diag::err_imported_module_relocated)
2979 if (ASTReadResult
Result =
2980 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2986 NumUserInputs =
Record[1];
2988 (
const llvm::support::unaligned_uint64_t *)Blob.data();
2997void ASTReader::readIncludedFiles(
ModuleFile &F, StringRef Blob,
2999 using namespace llvm::support;
3001 const unsigned char *D = (
const unsigned char *)Blob.data();
3002 unsigned FileCount = endian::readNext<uint32_t, little, unaligned>(D);
3004 for (
unsigned I = 0; I < FileCount; ++I) {
3005 size_t ID = endian::readNext<uint32_t, little, unaligned>(D);
3007 if (llvm::ErrorOr<const FileEntry *>
File =
3013llvm::Error ASTReader::ReadASTBlock(
ModuleFile &F,
3014 unsigned ClientLoadCapabilities) {
3015 BitstreamCursor &Stream = F.
Stream;
3017 if (llvm::Error Err = Stream.EnterSubBlock(
AST_BLOCK_ID))
3026 return MaybeEntry.takeError();
3027 llvm::BitstreamEntry Entry = MaybeEntry.get();
3029 switch (Entry.Kind) {
3030 case llvm::BitstreamEntry::Error:
3031 return llvm::createStringError(
3032 std::errc::illegal_byte_sequence,
3033 "error at end of module block in AST file");
3034 case llvm::BitstreamEntry::EndBlock:
3046 return llvm::Error::success();
3047 case llvm::BitstreamEntry::SubBlock:
3055 if (llvm::Error Err = Stream.SkipBlock())
3057 if (llvm::Error Err = ReadBlockAbbrevs(
3067 if (llvm::Error Err = Stream.SkipBlock())
3069 if (llvm::Error Err =
3078 if (llvm::Error Err = Stream.SkipBlock()) {
3094 if (llvm::Error Err = ReadSourceManagerBlock(F))
3099 if (llvm::Error Err = ReadSubmoduleBlock(F, ClientLoadCapabilities))
3104 BitstreamCursor
C = Stream;
3106 if (llvm::Error Err = Stream.SkipBlock())
3110 CommentsCursors.push_back(std::make_pair(
C, &F));
3115 if (llvm::Error Err = Stream.SkipBlock())
3121 case llvm::BitstreamEntry::Record:
3130 Stream.readRecord(Entry.ID, Record, &Blob);
3131 if (!MaybeRecordType)
3132 return MaybeRecordType.takeError();
3165 return llvm::createStringError(
3166 std::errc::illegal_byte_sequence,
3167 "duplicate TYPE_OFFSET record in AST file");
3170 unsigned LocalBaseTypeIndex =
Record[1];
3175 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3179 std::make_pair(LocalBaseTypeIndex,
3189 return llvm::createStringError(
3190 std::errc::illegal_byte_sequence,
3191 "duplicate DECL_OFFSET record in AST file");
3194 unsigned LocalBaseDeclID =
Record[1];
3200 GlobalDeclMap.insert(
3206 std::make_pair(LocalBaseDeclID, F.
BaseDeclID - LocalBaseDeclID));
3218 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3219 LexicalContents Contents(
3220 reinterpret_cast<const llvm::support::unaligned_uint32_t *
>(
3222 static_cast<unsigned int>(Blob.size() / 4));
3223 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3231 auto *
Data = (
const unsigned char*)Blob.data();
3232 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&F,
Data});
3235 if (
Decl *D = GetExistingDecl(ID))
3236 PendingUpdateRecords.push_back(
3237 PendingUpdateRecord(ID, D,
false));
3243 reinterpret_cast<const unsigned char *
>(Blob.data());
3257 return llvm::createStringError(
3258 std::errc::illegal_byte_sequence,
3259 "duplicate IDENTIFIER_OFFSET record in AST file");
3262 unsigned LocalBaseIdentifierID =
Record[1];
3268 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3274 std::make_pair(LocalBaseIdentifierID,
3277 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3290 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3291 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3298 getContext().getLangOpts().BuildingPCHWithObjectFile)
3299 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3300 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3304 if (SpecialTypes.empty()) {
3305 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3306 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
3310 if (SpecialTypes.size() !=
Record.size())
3311 return llvm::createStringError(std::errc::illegal_byte_sequence,
3312 "invalid special-types record");
3314 for (
unsigned I = 0, N =
Record.size(); I != N; ++I) {
3316 if (!SpecialTypes[I])
3317 SpecialTypes[I] =
ID;
3324 TotalNumStatements +=
Record[0];
3325 TotalNumMacros +=
Record[1];
3326 TotalLexicalDeclContexts +=
Record[2];
3327 TotalVisibleDeclContexts +=
Record[3];
3331 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3332 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
3336 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3337 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3341 if (
Record.size() % 3 != 0)
3342 return llvm::createStringError(std::errc::illegal_byte_sequence,
3343 "invalid weak identifiers record");
3347 WeakUndeclaredIdentifiers.clear();
3350 for (
unsigned I = 0, N =
Record.size(); I < N; ) {
3351 WeakUndeclaredIdentifiers.push_back(
3352 getGlobalIdentifierID(F, Record[I++]));
3353 WeakUndeclaredIdentifiers.push_back(
3354 getGlobalIdentifierID(F, Record[I++]));
3355 WeakUndeclaredIdentifiers.push_back(
3356 ReadSourceLocation(F, Record, I).getRawEncoding());
3363 unsigned LocalBaseSelectorID =
Record[1];
3369 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3374 std::make_pair(LocalBaseSelectorID,
3386 = ASTSelectorLookupTable::Create(
3390 TotalNumMethodPoolEntries +=
Record[1];
3395 for (
unsigned Idx = 0, N =
Record.size() - 1; Idx < N; ) {
3396 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3398 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3408 ReadSourceLocation(F, Record, Idx));
3414 unsigned Idx = 0, End =
Record.size() - 1;
3415 bool ReachedEOFWhileSkipping =
Record[Idx++];
3416 std::optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3417 if (ReachedEOFWhileSkipping) {
3420 bool FoundNonSkipPortion =
Record[Idx++];
3421 bool FoundElse =
Record[Idx++];
3423 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3424 FoundElse, ElseLoc);
3428 auto Loc = ReadSourceLocation(F, Record, Idx);
3429 bool WasSkipping =
Record[Idx++];
3430 bool FoundNonSkip =
Record[Idx++];
3431 bool FoundElse =
Record[Idx++];
3432 ConditionalStack.push_back(
3433 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3440 if (!
Record.empty() && Listener)
3458 if (!Diags.isDiagnosticInFlight()) {
3460 SourceMgr.noteSLocAddressSpaceUsage(Diags);
3462 return llvm::createStringError(std::errc::invalid_argument,
3463 "ran out of source locations");
3468 unsigned RangeStart =
3470 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3475 GlobalSLocOffsetMap.insert(
3477 - SLocSpaceSize,&F));
3495 ParseLineTable(F, Record);
3502 return llvm::createStringError(
3503 std::errc::illegal_byte_sequence,
3504 "Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3511 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3512 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3516 if (
Record.size() % 3 != 0)
3517 return llvm::createStringError(std::errc::illegal_byte_sequence,
3518 "Invalid VTABLE_USES record");
3525 for (
unsigned Idx = 0, N =
Record.size(); Idx != N; ) {
3526 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3527 VTableUses.push_back(
3528 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3529 VTableUses.push_back(Record[Idx++]);
3534 if (PendingInstantiations.size() % 2 != 0)
3535 return llvm::createStringError(
3536 std::errc::illegal_byte_sequence,
3537 "Invalid existing PendingInstantiations");
3539 if (
Record.size() % 2 != 0)
3540 return llvm::createStringError(
3541 std::errc::illegal_byte_sequence,
3542 "Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3544 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3545 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3546 PendingInstantiations.push_back(
3547 ReadSourceLocation(F, Record, I).getRawEncoding());
3553 return llvm::createStringError(std::errc::illegal_byte_sequence,
3554 "Invalid SEMA_DECL_REFS block");
3555 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3556 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3564 unsigned LocalBasePreprocessedEntityID =
Record[0];
3566 unsigned StartingID;
3579 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3584 std::make_pair(LocalBasePreprocessedEntityID,
3604 GlobalSkippedRangeMap.insert(
3610 if (
Record.size() % 2 != 0)
3611 return llvm::createStringError(
3612 std::errc::illegal_byte_sequence,
3613 "invalid DECL_UPDATE_OFFSETS block in AST file");
3614 for (
unsigned I = 0, N =
Record.size(); I != N; I += 2) {
3616 DeclUpdateOffsets[
ID].push_back(std::make_pair(&F, Record[I + 1]));
3620 if (
Decl *D = GetExistingDecl(ID))
3621 PendingUpdateRecords.push_back(
3622 PendingUpdateRecord(ID, D,
false));
3628 return llvm::createStringError(
3629 std::errc::illegal_byte_sequence,
3630 "duplicate OBJC_CATEGORIES_MAP record in AST file");
3643 CUDASpecialDeclRefs.clear();
3644 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3645 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3653 = HeaderFileInfoLookupTable::Create(
3658 Blob.data() + Record[2]));
3668 FPPragmaOptions.swap(Record);
3672 for (
unsigned I = 0, E =
Record.size(); I != E; ) {
3673 auto Name = ReadString(Record, I);
3674 auto &OptInfo = OpenCLExtensions.OptMap[Name];
3675 OptInfo.Supported =
Record[I++] != 0;
3676 OptInfo.Enabled =
Record[I++] != 0;
3677 OptInfo.WithPragma =
Record[I++] != 0;
3678 OptInfo.Avail =
Record[I++];
3679 OptInfo.Core =
Record[I++];
3680 OptInfo.Opt =
Record[I++];
3685 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3686 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3690 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3691 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3695 if (UndefinedButUsed.size() % 2 != 0)
3696 return llvm::createStringError(std::errc::illegal_byte_sequence,
3697 "Invalid existing UndefinedButUsed");
3699 if (
Record.size() % 2 != 0)
3700 return llvm::createStringError(std::errc::illegal_byte_sequence,
3701 "invalid undefined-but-used record");
3702 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3703 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3704 UndefinedButUsed.push_back(
3705 ReadSourceLocation(F, Record, I).getRawEncoding());
3710 for (
unsigned I = 0, N =
Record.size(); I != N;) {
3711 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3713 DelayedDeleteExprs.push_back(Count);
3714 for (uint64_t
C = 0;
C < Count; ++
C) {
3715 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3716 bool IsArrayForm =
Record[I++] == 1;
3717 DelayedDeleteExprs.push_back(IsArrayForm);
3727 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3728 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3731 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3732 if (DeserializationListener)
3733 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3741 return llvm::createStringError(
3742 std::errc::illegal_byte_sequence,
3743 "duplicate MACRO_OFFSET record in AST file");
3746 unsigned LocalBaseMacroID =
Record[1];
3752 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3756 std::make_pair(LocalBaseMacroID,
3765 readIncludedFiles(F, Blob, PP);
3769 LateParsedTemplates.emplace_back(
3770 std::piecewise_construct, std::forward_as_tuple(&F),
3776 return llvm::createStringError(std::errc::illegal_byte_sequence,
3777 "invalid pragma optimize record");
3778 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3783 return llvm::createStringError(std::errc::illegal_byte_sequence,
3784 "invalid pragma ms_struct record");
3785 PragmaMSStructState =
Record[0];
3790 return llvm::createStringError(
3791 std::errc::illegal_byte_sequence,
3792 "invalid pragma pointers to members record");
3793 PragmaMSPointersToMembersState =
Record[0];
3794 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3798 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3799 UnusedLocalTypedefNameCandidates.push_back(
3800 getGlobalDeclID(F, Record[I]));
3805 return llvm::createStringError(std::errc::illegal_byte_sequence,
3806 "invalid cuda pragma options record");
3807 ForceCUDAHostDeviceDepth =
Record[0];
3812 return llvm::createStringError(std::errc::illegal_byte_sequence,
3813 "invalid pragma pack record");
3814 PragmaAlignPackCurrentValue = ReadAlignPackInfo(Record[0]);
3815 PragmaAlignPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3816 unsigned NumStackEntries =
Record[2];
3819 PragmaAlignPackStack.clear();
3820 for (
unsigned I = 0; I < NumStackEntries; ++I) {
3821 PragmaAlignPackStackEntry Entry;
3822 Entry.Value = ReadAlignPackInfo(Record[Idx++]);
3823 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3824 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3825 PragmaAlignPackStrings.push_back(ReadString(Record, Idx));
3826 Entry.SlotLabel = PragmaAlignPackStrings.back();
3827 PragmaAlignPackStack.push_back(Entry);
3834 return llvm::createStringError(std::errc::illegal_byte_sequence,
3835 "invalid pragma float control record");
3837 FpPragmaCurrentLocation = ReadSourceLocation(F, Record[1]);
3838 unsigned NumStackEntries =
Record[2];
3841 FpPragmaStack.clear();
3842 for (
unsigned I = 0; I < NumStackEntries; ++I) {
3843 FpPragmaStackEntry Entry;
3845 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3846 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3847 FpPragmaStrings.push_back(ReadString(Record, Idx));
3848 Entry.SlotLabel = FpPragmaStrings.back();
3849 FpPragmaStack.push_back(Entry);
3855 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3856 DeclsToCheckForDeferredDiags.insert(getGlobalDeclID(F, Record[I]));
3862void ASTReader::ReadModuleOffsetMap(
ModuleFile &F)
const {
3877 using SLocRemapBuilder =
3890 while (
Data < DataEnd) {
3894 using namespace llvm::support;
3896 endian::readNext<uint8_t, little, unaligned>(
Data));
3897 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(
Data);
3898 StringRef Name = StringRef((
const char*)
Data, Len);
3902 ? ModuleMgr.lookupByModuleName(Name)
3903 : ModuleMgr.lookupByFileName(Name));
3906 "SourceLocation remap refers to unknown module, cannot find ";
3907 Msg.append(std::string(Name));
3913 endian::readNext<uint32_t, little, unaligned>(
Data);
3914 uint32_t IdentifierIDOffset =
3915 endian::readNext<uint32_t, little, unaligned>(
Data);
3916 uint32_t MacroIDOffset =
3917 endian::readNext<uint32_t, little, unaligned>(
Data);
3918 uint32_t PreprocessedEntityIDOffset =
3919 endian::readNext<uint32_t, little, unaligned>(
Data);
3920 uint32_t SubmoduleIDOffset =
3921 endian::readNext<uint32_t, little, unaligned>(
Data);
3922 uint32_t SelectorIDOffset =
3923 endian::readNext<uint32_t, little, unaligned>(
Data);
3924 uint32_t DeclIDOffset =
3925 endian::readNext<uint32_t, little, unaligned>(
Data);
3926 uint32_t TypeIndexOffset =
3927 endian::readNext<uint32_t, little, unaligned>(
Data);
3929 auto mapOffset = [&](uint32_t
Offset, uint32_t BaseOffset,
3930 RemapBuilder &Remap) {
3931 constexpr uint32_t
None = std::numeric_limits<uint32_t>::max();
3933 Remap.insert(std::make_pair(
Offset,
3934 static_cast<int>(BaseOffset -
Offset)));
3938 std::numeric_limits<SourceLocation::UIntTy>::max();
3939 if (SLocOffset != SLocNone)
3945 mapOffset(MacroIDOffset, OM->
BaseMacroID, MacroRemap);
3947 PreprocessedEntityRemap);
3950 mapOffset(DeclIDOffset, OM->
BaseDeclID, DeclRemap);
3959ASTReader::ReadModuleMapFileBlock(RecordData &Record,
ModuleFile &F,
3961 unsigned ClientLoadCapabilities) {
3970 "MODULE_NAME should come before MODULE_MAP_FILE");
3978 M ? Map.getModuleMapFileForUniquing(M) : std::nullopt;
3983 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities)) {
3984 if (
auto ASTFE = M ? M->
getASTFile() : std::nullopt) {
3987 << ASTFE->getName();
3990 Diag(diag::err_imported_module_not_found)
3998 Diag(diag::note_imported_by_pch_module_not_found)
4005 assert(M && M->
Name == F.
ModuleName &&
"found module with different name");
4009 if (!StoredModMap || *StoredModMap != ModMap) {
4010 assert(ModMap &&
"found module is missing module map file");
4012 "top-level import should be verified");
4014 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4015 Diag(diag::err_imported_module_modmap_changed)
4022 for (
unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
4024 std::string
Filename = ReadPath(F, Record, Idx);
4025 auto SF = FileMgr.getFile(
Filename,
false,
false);
4027 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4028 Error(
"could not find file '" +
Filename +
"' referenced by AST file");
4031 AdditionalStoredMaps.insert(*SF);
4036 if (
auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
4037 for (
const FileEntry *ModMap : *AdditionalModuleMaps) {
4040 if (!AdditionalStoredMaps.erase(ModMap)) {
4041 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4042 Diag(diag::err_module_different_modmap)
4051 for (
const FileEntry *ModMap : AdditionalStoredMaps) {
4052 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4053 Diag(diag::err_module_different_modmap)
4074 : Known->second.second;
4076 for (
ObjCMethodList *List = &Start; List; List = List->getNext()) {
4078 if (List->getMethod() == Method) {
4086 if (List->getNext())
4087 List->setMethod(List->getNext()->getMethod());
4089 List->setMethod(Method);
4095 for (
Decl *D : Names) {
4096 bool wasHidden = !D->isUnconditionallyVisible();
4097 D->setVisibleDespiteOwningModule();
4099 if (wasHidden && SemaObj) {
4112 Stack.push_back(Mod);
4113 while (!Stack.empty()) {
4114 Mod = Stack.pop_back_val();
4116 if (NameVisibility <= Mod->NameVisibility) {
4132 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4133 if (Hidden != HiddenNamesMap.end()) {
4135 HiddenNamesMap.erase(Hidden);
4137 assert(!HiddenNamesMap.contains(Mod) &&
4138 "making names visible added hidden names");
4145 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4147 if (Visited.insert(Exported).second)
4148 Stack.push_back(Exported);
4163 getContext().mergeDefinitionIntoModule(
4166 PendingMergedDefinitionsToDeduplicate.insert(Def);
4175 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4180 TriedLoadingGlobalIndex =
true;
4181 StringRef ModuleCachePath
4182 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4183 std::pair<GlobalModuleIndex *, llvm::Error>
Result =
4185 if (llvm::Error Err = std::move(
Result.second)) {
4187 consumeError(std::move(Err));
4191 GlobalIndex.reset(
Result.first);
4192 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4197 return PP.
getLangOpts().Modules && UseGlobalIndex &&
4198 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4205 llvm::raw_fd_ostream
OS(TimestampFilename, EC,
4206 llvm::sys::fs::OF_TextWithCRLF);
4209 OS <<
"Timestamp file\n";
4222 consumeError(MaybeEntry.takeError());
4225 llvm::BitstreamEntry Entry = MaybeEntry.get();
4227 switch (Entry.Kind) {
4228 case llvm::BitstreamEntry::Error:
4229 case llvm::BitstreamEntry::EndBlock:
4232 case llvm::BitstreamEntry::Record:
4238 consumeError(Skipped.takeError());
4242 case llvm::BitstreamEntry::SubBlock:
4243 if (Entry.ID == BlockID) {
4244 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4246 consumeError(std::move(Err));
4253 if (llvm::Error Err = Cursor.SkipBlock()) {
4255 consumeError(std::move(Err));
4265 unsigned ClientLoadCapabilities,
4267 llvm::TimeTraceScope scope(
"ReadAST", FileName);
4271 CurrentDeserializingModuleKind,
Type);
4277 unsigned PreviousGeneration = 0;
4279 PreviousGeneration = incrementGeneration(*ContextObj);
4281 unsigned NumModules = ModuleMgr.size();
4284 ReadASTCore(FileName,
Type, ImportLoc,
4286 ClientLoadCapabilities)) {
4287 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules);
4291 GlobalIndex.reset();
4292 ModuleMgr.setGlobalIndex(
nullptr);
4305 for (ImportedModule &M : Loaded) {
4307 llvm::TimeTraceScope Scope2(
"Read Loaded AST", F.
ModuleName);
4310 if (llvm::Error Err = ReadASTBlock(F, ClientLoadCapabilities)) {
4311 Error(std::move(Err));
4317 Error(diag::err_module_file_missing_top_level_submodule, F.
FileName);
4323 if (llvm::Error Err = ReadExtensionBlock(F)) {
4324 Error(std::move(Err));
4337 for (ImportedModule &M : Loaded) {
4347 SourceMgr.getLoadedSLocEntryByID(Index);
4372 SetIdentifierInfo(ID, &II);
4378 for (ImportedModule &M : Loaded) {
4381 ModuleMgr.moduleFileAccepted(&F);
4390 F.
ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4406 Id->second->setOutOfDate(
true);
4409 for (
auto Sel : SelectorGeneration)
4410 SelectorOutOfDate[Sel.first] =
true;
4413 for (
unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4414 UnresolvedModuleRef &
Unresolved = UnresolvedModuleRefs[I];
4416 Module *ResolvedMod = getSubmodule(GlobalID);
4419 case UnresolvedModuleRef::Conflict:
4422 Conflict.
Other = ResolvedMod;
4424 Unresolved.Mod->Conflicts.push_back(Conflict);
4428 case UnresolvedModuleRef::Import:
4433 case UnresolvedModuleRef::Affecting:
4435 Unresolved.Mod->AffectingClangModules.insert(ResolvedMod);
4438 case UnresolvedModuleRef::Export:
4445 UnresolvedModuleRefs.clear();
4448 Imported->append(ImportedModules.begin(),
4449 ImportedModules.end());
4456 InitializeContext();
4461 if (DeserializationListener)
4462 DeserializationListener->ReaderInitialized(
this);
4464 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4479 for (
unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4480 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4481 ObjCClassesLoaded[I],
4482 PreviousGeneration);
4493 for (
unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4494 ImportedModule &M = Loaded[I];
4511 if (!Stream.canSkipToPos(4))
4512 return llvm::createStringError(std::errc::illegal_byte_sequence,
4513 "file too small to contain AST file magic");
4514 for (
unsigned C : {
'C',
'P',
'C',
'H'})
4517 return llvm::createStringError(
4518 std::errc::illegal_byte_sequence,
4519 "file doesn't start with AST file magic");
4521 return Res.takeError();
4522 return llvm::Error::success();
4537 llvm_unreachable(
"unknown module kind");
4541ASTReader::ReadASTCore(StringRef FileName,
4546 off_t ExpectedSize, time_t ExpectedModTime,
4548 unsigned ClientLoadCapabilities) {
4550 std::string ErrorStr;
4552 = ModuleMgr.addModule(FileName,
Type, ImportLoc, ImportedBy,
4553 getGeneration(), ExpectedSize, ExpectedModTime,
4557 switch (AddResult) {
4559 Diag(diag::remark_module_import)
4561 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
4571 if (ClientLoadCapabilities & ARR_Missing)
4575 Diag(diag::err_ast_file_not_found)
4583 if (ClientLoadCapabilities & ARR_OutOfDate)
4587 Diag(diag::err_ast_file_out_of_date)
4593 assert(M &&
"Missing module file");
4595 bool ShouldFinalizePCM =
false;
4596 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4597 auto &MC = getModuleManager().getModuleCache();
4598 if (ShouldFinalizePCM)
4599 MC.finalizePCM(FileName);
4601 MC.tryToDropPCM(FileName);
4604 BitstreamCursor &Stream = F.
Stream;
4605 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4606 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4610 Diag(diag::err_ast_file_invalid)
4616 bool HaveReadControlBlock =
false;
4620 Error(MaybeEntry.takeError());
4623 llvm::BitstreamEntry Entry = MaybeEntry.get();
4625 switch (Entry.Kind) {
4626 case llvm::BitstreamEntry::Error:
4627 case llvm::BitstreamEntry::Record:
4628 case llvm::BitstreamEntry::EndBlock:
4629 Error(
"invalid record at top-level of AST file");
4632 case llvm::BitstreamEntry::SubBlock:
4638 HaveReadControlBlock =
true;
4639 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4647 F.ModuleName.empty()) {
4649 if (
Result != OutOfDate ||
4650 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4651 Diag(diag::err_module_file_not_module) << FileName;
4656 case Failure:
return Failure;
4657 case Missing:
return Missing;
4658 case OutOfDate:
return OutOfDate;
4660 case ConfigurationMismatch:
return ConfigurationMismatch;
4661 case HadErrors:
return HadErrors;
4666 if (!HaveReadControlBlock) {
4667 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4668 Diag(diag::err_pch_version_too_old);
4673 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4674 ShouldFinalizePCM =
true;
4680 Error(
"malformed block record in AST file");
4684 if (llvm::Error Err = Stream.SkipBlock()) {
4685 Error(std::move(Err));
4692 llvm_unreachable(
"unexpected break; expected return");
4696ASTReader::readUnhashedControlBlock(
ModuleFile &F,
bool WasImportedBy,
4697 unsigned ClientLoadCapabilities) {
4700 bool AllowCompatibleConfigurationMismatch =
4702 bool DisableValidation = shouldDisableValidationForFile(F);
4704 ASTReadResult
Result = readUnhashedControlBlockImpl(
4705 &F, F.
Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4711 if (DisableValidation || WasImportedBy ||
4712 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
4716 Error(
"malformed block record in AST file");
4739 if (getModuleManager().getModuleCache().isPCMFinal(F.
FileName)) {
4740 Diag(diag::warn_module_system_bit_conflict) << F.
FileName;
4749 ModuleFile *F, llvm::StringRef StreamData,
unsigned ClientLoadCapabilities,
4751 bool ValidateDiagnosticOptions) {
4753 BitstreamCursor Stream(StreamData);
4758 consumeError(std::move(Err));
4773 consumeError(MaybeEntry.takeError());
4776 llvm::BitstreamEntry Entry = MaybeEntry.get();
4778 switch (Entry.Kind) {
4779 case llvm::BitstreamEntry::Error:
4780 case llvm::BitstreamEntry::SubBlock:
4783 case llvm::BitstreamEntry::EndBlock:
4786 case llvm::BitstreamEntry::Record:
4795 Stream.readRecord(Entry.ID, Record, &Blob);
4796 if (!MaybeRecordType) {
4811 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4812 if (Listener && ValidateDiagnosticOptions &&
4813 !AllowCompatibleConfigurationMismatch &&
4814 ParseDiagnosticOptions(Record, Complain, *Listener))
4819 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
4820 if (!AllowCompatibleConfigurationMismatch &&
4821 ParseHeaderSearchPaths(Record, Complain, *Listener))
4822 Result = ConfigurationMismatch;
4837 unsigned Count =
Record[0];
4838 const char *Byte = Blob.data();
4840 for (
unsigned I = 0; I < Count; ++Byte)
4841 for (
unsigned Bit = 0; Bit < 8 && I < Count; ++Bit, ++I)
4842 if (*Byte & (1 << Bit))
4854 if (Record.size() < 4)
return true;
4859 unsigned BlockNameLen = Record[2];
4860 unsigned UserInfoLen = Record[3];
4862 if (BlockNameLen + UserInfoLen > Blob.size())
return true;
4864 Metadata.
BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4865 Metadata.
UserInfo = std::string(Blob.data() + BlockNameLen,
4866 Blob.data() + BlockNameLen + UserInfoLen);
4870llvm::Error ASTReader::ReadExtensionBlock(
ModuleFile &F) {
4871 BitstreamCursor &Stream = F.
Stream;
4877 return MaybeEntry.takeError();
4878 llvm::BitstreamEntry Entry = MaybeEntry.get();
4880 switch (Entry.Kind) {
4881 case llvm::BitstreamEntry::SubBlock:
4882 if (llvm::Error Err = Stream.SkipBlock())
4885 case llvm::BitstreamEntry::EndBlock:
4886 return llvm::Error::success();
4887 case llvm::BitstreamEntry::Error:
4888 return llvm::createStringError(std::errc::illegal_byte_sequence,
4889 "malformed block record in AST file");
4890 case llvm::BitstreamEntry::Record:
4897 Stream.readRecord(Entry.ID, Record, &Blob);
4899 return MaybeRecCode.takeError();
4900 switch (MaybeRecCode.get()) {
4904 return llvm::createStringError(
4905 std::errc::illegal_byte_sequence,
4906 "malformed EXTENSION_METADATA in AST file");
4909 auto Known = ModuleFileExtensions.find(Metadata.
BlockName);
4910 if (Known == ModuleFileExtensions.end())
break;
4913 if (
auto Reader = Known->second->createExtensionReader(Metadata, *
this,
4923 return llvm::Error::success();
4927 assert(ContextObj &&
"no context to initialize");
4931 if (DeserializationListener)
4941 if (!Context.CFConstantStringTypeDecl)
4948 Error(
"FILE type is NULL");
4952 if (!Context.FILEDecl) {
4958 Error(
"Invalid FILE type in AST file");
4967 QualType Jmp_bufType = GetType(Jmp_buf);
4968 if (Jmp_bufType.
isNull()) {
4969 Error(
"jmp_buf type is NULL");
4973 if (!Context.jmp_bufDecl) {
4979 Error(
"Invalid jmp_buf type in AST file");
4988 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4989 if (Sigjmp_bufType.
isNull()) {
4990 Error(
"sigjmp_buf type is NULL");
4994 if (!Context.sigjmp_bufDecl) {
4999 assert(Tag &&
"Invalid sigjmp_buf type in AST file");
5005 if (
unsigned ObjCIdRedef
5007 if (Context.ObjCIdRedefinitionType.
isNull())
5008 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
5011 if (
unsigned ObjCClassRedef
5013 if (Context.ObjCClassRedefinitionType.
isNull())
5014 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
5017 if (
unsigned ObjCSelRedef
5019 if (Context.ObjCSelRedefinitionType.
isNull())
5020 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
5024 QualType Ucontext_tType = GetType(Ucontext_t);
5025 if (Ucontext_tType.
isNull()) {
5026 Error(
"ucontext_t type is NULL");
5030 if (!Context.ucontext_tDecl) {
5035 assert(Tag &&
"Invalid ucontext_t type in AST file");
5045 if (!CUDASpecialDeclRefs.empty()) {
5046 assert(CUDASpecialDeclRefs.size() == 1 &&
"More decl refs than expected!");
5048 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5053 for (
auto &Import : ImportedModules) {
5054 if (
Module *Imported = getSubmodule(Import.ID)) {
5057 if (Import.ImportLoc.isValid())
5072 BitstreamCursor Stream(
PCH);
5075 consumeError(std::move(Err));
5087 Stream.advanceSkippingSubblocks();
5090 consumeError(MaybeEntry.takeError());
5093 llvm::BitstreamEntry Entry = MaybeEntry.get();
5095 if (Entry.Kind != llvm::BitstreamEntry::Record)
5103 consumeError(MaybeRecord.takeError());
5116 const std::string &ASTFileName,
FileManager &FileMgr,
5122 Diags.
Report(diag::err_fe_unable_to_read_pch_file)
5123 << ASTFileName << Buffer.getError().message();
5124 return std::string();
5128 BitstreamCursor Stream(PCHContainerRdr.
ExtractPCH(**Buffer));
5132 Diags.
Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5133 return std::string();
5138 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5139 return std::string();
5146 Stream.advanceSkippingSubblocks();
5149 consumeError(MaybeEntry.takeError());
5150 return std::string();
5152 llvm::BitstreamEntry Entry = MaybeEntry.get();
5154 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5155 return std::string();
5157 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5158 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5159 return std::string();
5167 consumeError(MaybeRecord.takeError());
5168 return std::string();
5181 std::string ExistingModuleCachePath;
5183 bool StrictOptionMatches;
5186 SimplePCHValidator(
const LangOptions &ExistingLangOpts,
5189 StringRef ExistingModuleCachePath,
FileManager &FileMgr,
5190 bool StrictOptionMatches)
5191 : ExistingLangOpts(ExistingLangOpts),
5192 ExistingTargetOpts(ExistingTargetOpts),
5193 ExistingPPOpts(ExistingPPOpts),
5194 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr),
5195 StrictOptionMatches(StrictOptionMatches) {}
5197 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
5198 bool AllowCompatibleDifferences)
override {
5200 AllowCompatibleDifferences);
5203 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
5204 bool AllowCompatibleDifferences)
override {
5206 AllowCompatibleDifferences);
5210 StringRef SpecificModuleCachePath,
5211 bool Complain)
override {
5213 ExistingModuleCachePath,
nullptr,
5214 ExistingLangOpts, ExistingPPOpts);
5219 std::string &SuggestedPredefines)
override {
5221 PPOpts, ExistingPPOpts,
nullptr, FileMgr,
5222 SuggestedPredefines, ExistingLangOpts,
5236 std::unique_ptr<llvm::MemoryBuffer> OwnedBuffer;
5248 OwnedBuffer = std::move(*BufferOrErr);
5249 Buffer = OwnedBuffer.get();
5253 StringRef Bytes = PCHContainerRdr.
ExtractPCH(*Buffer);
5254 BitstreamCursor Stream(Bytes);
5258 consumeError(std::move(Err));
5269 BitstreamCursor InputFilesCursor;
5272 std::string ModuleDir;
5273 bool DoneWithControlBlock =
false;
5274 while (!DoneWithControlBlock) {
5278 consumeError(MaybeEntry.takeError());
5281 llvm::BitstreamEntry Entry = MaybeEntry.get();
5283 switch (Entry.Kind) {
5284 case llvm::BitstreamEntry::SubBlock: {
5287 std::string IgnoredSuggestedPredefines;
5288 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
5290 Listener, IgnoredSuggestedPredefines) != Success)
5296 InputFilesCursor = Stream;
5297 if (llvm::Error Err = Stream.SkipBlock()) {
5299 consumeError(std::move(Err));
5302 if (NeedsInputFiles &&
5308 if (llvm::Error Err = Stream.SkipBlock()) {
5310 consumeError(std::move(Err));
5319 case llvm::BitstreamEntry::EndBlock:
5320 DoneWithControlBlock =
true;
5323 case llvm::BitstreamEntry::Error:
5326 case llvm::BitstreamEntry::Record:
5330 if (DoneWithControlBlock)
break;
5335 Stream.readRecord(Entry.ID, Record, &Blob);
5336 if (!MaybeRecCode) {
5351 ModuleDir = std::string(Blob);
5355 auto Path = ReadString(Record, Idx);
5356 ResolveImportedPath(Path, ModuleDir);
5361 if (!NeedsInputFiles)
5364 unsigned NumInputFiles = Record[0];
5365 unsigned NumUserFiles = Record[1];
5366 const llvm::support::unaligned_uint64_t *InputFileOffs =
5367 (
const llvm::support::unaligned_uint64_t *)Blob.data();
5368 for (
unsigned I = 0; I != NumInputFiles; ++I) {
5370 bool isSystemFile = I >= NumUserFiles;
5372 if (isSystemFile && !NeedsSystemInputFiles)
5375 BitstreamCursor &Cursor = InputFilesCursor;
5377 if (llvm::Error Err = Cursor.JumpToBit(InputFileOffs[I])) {
5379 consumeError(std::move(Err));
5385 consumeError(MaybeCode.takeError());
5387 unsigned Code = MaybeCode.get();
5391 bool shouldContinue =
false;
5393 Cursor.readRecord(Code, Record, &Blob);