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, ReadMacros, Complain,
214 SuggestedPredefines) ||
215 Second->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
216 SuggestedPredefines);
221 First->ReadCounter(M,
Value);
222 Second->ReadCounter(M,
Value);
226 return First->needsInputFileVisitation() ||
227 Second->needsInputFileVisitation();
231 return First->needsSystemInputFileVisitation() ||
232 Second->needsSystemInputFileVisitation();
237 First->visitModuleFile(
Filename, Kind);
238 Second->visitModuleFile(
Filename, Kind);
244 bool isExplicitModule) {
245 bool Continue =
false;
246 if (First->needsInputFileVisitation() &&
247 (!isSystem || First->needsSystemInputFileVisitation()))
248 Continue |= First->visitInputFile(
Filename, isSystem, isOverridden,
250 if (Second->needsInputFileVisitation() &&
251 (!isSystem || Second->needsSystemInputFileVisitation()))
252 Continue |= Second->visitInputFile(
Filename, isSystem, isOverridden,
259 First->readModuleFileExtension(Metadata);
260 Second->readModuleFileExtension(Metadata);
280 bool AllowCompatibleDifferences =
true) {
281#define LANGOPT(Name, Bits, Default, Description) \
282 if (ExistingLangOpts.Name != LangOpts.Name) { \
285 Diags->Report(diag::err_pch_langopt_mismatch) \
286 << Description << LangOpts.Name << ExistingLangOpts.Name; \
288 Diags->Report(diag::err_pch_langopt_value_mismatch) \
294#define VALUE_LANGOPT(Name, Bits, Default, Description) \
295 if (ExistingLangOpts.Name != LangOpts.Name) { \
297 Diags->Report(diag::err_pch_langopt_value_mismatch) \
302#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
303 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
305 Diags->Report(diag::err_pch_langopt_value_mismatch) \
310#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
311 if (!AllowCompatibleDifferences) \
312 LANGOPT(Name, Bits, Default, Description)
314#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
315 if (!AllowCompatibleDifferences) \
316 ENUM_LANGOPT(Name, Bits, Default, Description)
318#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
319 if (!AllowCompatibleDifferences) \
320 VALUE_LANGOPT(Name, Bits, Default, Description)
322#define BENIGN_LANGOPT(Name, Bits, Default, Description)
323#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
324#define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description)
325#include "clang/Basic/LangOptions.def"
329 Diags->
Report(diag::err_pch_langopt_value_mismatch) <<
"module features";
335 Diags->
Report(diag::err_pch_langopt_value_mismatch)
336 <<
"target Objective-C runtime";
343 Diags->
Report(diag::err_pch_langopt_value_mismatch)
344 <<
"block command names";
352 if (!AllowCompatibleDifferences) {
356 ExistingSanitizers.
clear(ModularSanitizers);
357 ImportedSanitizers.
clear(ModularSanitizers);
358 if (ExistingSanitizers.
Mask != ImportedSanitizers.
Mask) {
359 const std::string Flag =
"-fsanitize=";
361#define SANITIZER(NAME, ID) \
363 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
364 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
365 if (InExistingModule != InImportedModule) \
366 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
367 << InExistingModule << (Flag + NAME); \
369#include "clang/Basic/Sanitizers.def"
387 bool AllowCompatibleDifferences =
true) {
388#define CHECK_TARGET_OPT(Field, Name) \
389 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
391 Diags->Report(diag::err_pch_targetopt_mismatch) \
392 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
403 if (!AllowCompatibleDifferences) {
408#undef CHECK_TARGET_OPT
416 llvm::sort(ExistingFeatures);
417 llvm::sort(ReadFeatures);
423 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
424 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
425 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
426 ExistingFeatures.begin(), ExistingFeatures.end(),
427 std::back_inserter(UnmatchedReadFeatures));
431 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
435 for (StringRef Feature : UnmatchedReadFeatures)
436 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
438 for (StringRef Feature : UnmatchedExistingFeatures)
439 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
443 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
449 bool AllowCompatibleDifferences) {
452 Complain ? &Reader.Diags :
nullptr,
453 AllowCompatibleDifferences);
458 bool AllowCompatibleDifferences) {
461 Complain ? &Reader.Diags :
nullptr,
462 AllowCompatibleDifferences);
467using MacroDefinitionsMap =
468 llvm::StringMap<std::pair<StringRef,
bool >>;
469using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
484 for (
auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
493 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror=" +
512 bool SystemHeaderWarningsInModule,
521 !SystemHeaderWarningsInModule) {
523 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Wsystem-headers";
530 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror";
537 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Weverything -Werror";
544 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-pedantic-errors";
568 assert(!ModuleName.empty() &&
"diagnostic options read before module name");
572 assert(M &&
"missing module");
587 assert(ModuleMgr.
size() >= 1 &&
"what ASTFile is this then");
596 bool SystemHeaderWarningsInModule =
603 SystemHeaderWarningsInModule, Complain);
610 MacroDefinitionsMap &Macros,
612 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
613 StringRef Macro = PPOpts.
Macros[I].first;
614 bool IsUndef = PPOpts.
Macros[I].second;
616 std::pair<StringRef, StringRef> MacroPair = Macro.split(
'=');
617 StringRef MacroName = MacroPair.first;
618 StringRef MacroBody = MacroPair.second;
622 if (MacroNames && !Macros.count(MacroName))
623 MacroNames->push_back(MacroName);
625 Macros[MacroName] = std::make_pair(
"",
true);
630 if (MacroName.size() == Macro.size())
634 StringRef::size_type End = MacroBody.find_first_of(
"\n\r");
635 MacroBody = MacroBody.substr(0, End);
638 if (MacroNames && !Macros.count(MacroName))
639 MacroNames->push_back(MacroName);
640 Macros[MacroName] = std::make_pair(MacroBody,
false);
664 std::string &SuggestedPredefines,
const LangOptions &LangOpts,
668 MacroDefinitionsMap ASTFileMacros;
670 MacroDefinitionsMap ExistingMacros;
673 &ExistingMacroNames);
677 SuggestedPredefines +=
"# 1 \"<command line>\" 1\n";
679 for (
unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
681 StringRef MacroName = ExistingMacroNames[I];
682 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
685 llvm::StringMap<std::pair<StringRef,
bool >>::iterator Known =
686 ASTFileMacros.find(MacroName);
692 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
true;
700 if (Existing.second) {
701 SuggestedPredefines +=
"#undef ";
702 SuggestedPredefines += MacroName.str();
703 SuggestedPredefines +=
'\n';
705 SuggestedPredefines +=
"#define ";
706 SuggestedPredefines += MacroName.str();
707 SuggestedPredefines +=
' ';
708 SuggestedPredefines += Existing.first.str();
709 SuggestedPredefines +=
'\n';
716 if (Existing.second != Known->second.second) {
718 Diags->
Report(diag::err_pch_macro_def_undef)
719 << MacroName << Known->second.second;
726 if (Existing.second || Existing.first == Known->second.first) {
727 ASTFileMacros.erase(Known);
733 Diags->
Report(diag::err_pch_macro_def_conflict)
734 << MacroName << Known->second.first << Existing.first;
740 SuggestedPredefines +=
"# 1 \"<built-in>\" 2\n";
745 for (
const auto &MacroName : ASTFileMacros.keys()) {
747 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
false;
764 if (LangOpts.Modules &&
774 for (
unsigned I = 0, N = ExistingPPOpts.
Includes.size(); I != N; ++I) {
781 SuggestedPredefines +=
"#include \"";
782 SuggestedPredefines +=
File;
783 SuggestedPredefines +=
"\"\n";
793 SuggestedPredefines +=
"#include \"";
794 SuggestedPredefines +=
File;
795 SuggestedPredefines +=
"\"\n";
798 for (
unsigned I = 0, N = ExistingPPOpts.
MacroIncludes.size(); I != N; ++I) {
803 SuggestedPredefines +=
"#__include_macros \"";
804 SuggestedPredefines +=
File;
805 SuggestedPredefines +=
"\"\n##\n";
812 bool ReadMacros,
bool Complain,
813 std::string &SuggestedPredefines) {
817 PPOpts, ExistingPPOpts, ReadMacros, Complain ? &Reader.Diags :
nullptr,
823 std::string &SuggestedPredefines) {
835 StringRef SpecificModuleCachePath,
836 StringRef ExistingModuleCachePath,
840 if (LangOpts.Modules) {
841 if (SpecificModuleCachePath != ExistingModuleCachePath &&
844 Diags->
Report(diag::err_pch_modulecache_mismatch)
845 << SpecificModuleCachePath << ExistingModuleCachePath;
854 StringRef SpecificModuleCachePath,
858 Complain ? &Reader.Diags :
nullptr,
872 const char *Error =
nullptr;
874 uint64_t Val = llvm::decodeULEB128(
P, &Length,
nullptr, &Error);
876 llvm::report_fatal_error(Error);
882static std::pair<unsigned, unsigned>
885 if ((
unsigned)KeyLen != KeyLen)
886 llvm::report_fatal_error(
"key too large");
889 if ((
unsigned)DataLen != DataLen)
890 llvm::report_fatal_error(
"data too large");
892 return std::make_pair(KeyLen, DataLen);
896 bool TakeOwnership) {
897 DeserializationListener = Listener;
898 OwnsDeserializationListener = TakeOwnership;
905std::pair<unsigned, unsigned>
912 using namespace llvm::support;
915 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
917 F, endian::readNext<uint32_t, little, unaligned>(d));
924 Args.push_back(FirstII);
925 for (
unsigned I = 1; I != N; ++I)
926 Args.push_back(Reader.getLocalIdentifier(
927 F, endian::readNext<uint32_t, little, unaligned>(d)));
935 using namespace llvm::support;
939 Result.ID = Reader.getGlobalSelectorID(
940 F, endian::readNext<uint32_t, little, unaligned>(d));
941 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
942 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
943 Result.InstanceBits = FullInstanceBits & 0x3;
944 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
945 Result.FactoryBits = FullFactoryBits & 0x3;
946 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
947 unsigned NumInstanceMethods = FullInstanceBits >> 3;
948 unsigned NumFactoryMethods = FullFactoryBits >> 3;
951 for (
unsigned I = 0; I != NumInstanceMethods; ++I) {
953 F, endian::readNext<uint32_t, little, unaligned>(d)))
954 Result.Instance.push_back(Method);
958 for (
unsigned I = 0; I != NumFactoryMethods; ++I) {
960 F, endian::readNext<uint32_t, little, unaligned>(d)))
961 Result.Factory.push_back(Method);
968 return llvm::djbHash(a);
971std::pair<unsigned, unsigned>
978 assert(n >= 2 && d[n-1] ==
'\0');
979 return StringRef((
const char*) d, n-1);
993 bool Value = Bits & 0x1;
999 using namespace llvm::support;
1001 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
1002 return Reader.getGlobalIdentifierID(F, RawID >> 1);
1015 const unsigned char* d,
1017 using namespace llvm::support;
1019 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
1020 bool IsInteresting = RawID & 0x01;
1028 II = &Reader.getIdentifierTable().getOwn(k);
1032 Reader.markIdentifierUpToDate(II);
1034 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
1035 if (!IsInteresting) {
1038 Reader.SetIdentifierInfo(ID, II);
1042 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
1043 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
1044 bool CPlusPlusOperatorKeyword =
readBit(Bits);
1045 bool HasRevertedTokenIDToIdentifier =
readBit(Bits);
1046 bool Poisoned =
readBit(Bits);
1047 bool ExtensionToken =
readBit(Bits);
1048 bool HadMacroDefinition =
readBit(Bits);
1050 assert(Bits == 0 &&
"Extra bits in the identifier?");
1055 if (HasRevertedTokenIDToIdentifier && II->
getTokenID() != tok::identifier)
1060 "Incorrect extension token flag");
1061 (void)ExtensionToken;
1065 "Incorrect C++ operator keyword flag");
1066 (void)CPlusPlusOperatorKeyword;
1070 if (HadMacroDefinition) {
1071 uint32_t MacroDirectivesOffset =
1072 endian::readNext<uint32_t, little, unaligned>(d);
1075 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1078 Reader.SetIdentifierInfo(ID, II);
1084 for (; DataLen > 0; DataLen -= 4)
1085 DeclIDs.push_back(Reader.getGlobalDeclID(
1086 F, endian::readNext<uint32_t, little, unaligned>(d)));
1087 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1094 : Kind(Name.getNameKind()) {
1097 Data = (uint64_t)Name.getAsIdentifierInfo();
1102 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1105 Data = Name.getCXXOverloadedOperator();
1108 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1111 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1112 ->getDeclName().getAsIdentifierInfo();
1124 llvm::FoldingSetNodeID ID;
1125 ID.AddInteger(Kind);
1148 return ID.ComputeHash();
1152ASTDeclContextNameLookupTrait::ReadFileRef(
const unsigned char *&d) {
1153 using namespace llvm::support;
1155 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1156 return Reader.getLocalModuleFile(F, ModuleFileID);
1159std::pair<unsigned, unsigned>
1160ASTDeclContextNameLookupTrait::ReadKeyDataLength(
const unsigned char *&d) {
1165ASTDeclContextNameLookupTrait::ReadKey(
const unsigned char *d,
unsigned) {
1166 using namespace llvm::support;
1174 Data = (uint64_t)Reader.getLocalIdentifier(
1175 F, endian::readNext<uint32_t, little, unaligned>(d));
1181 (uint64_t)Reader.getLocalSelector(
1182 F, endian::readNext<uint32_t, little, unaligned>(
1183 d)).getAsOpaquePtr();
1200 const unsigned char *d,
1203 using namespace llvm::support;
1205 for (
unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1206 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1207 Val.
insert(Reader.getGlobalDeclID(F, LocalID));
1211bool ASTReader::ReadLexicalDeclContextStorage(
ModuleFile &M,
1212 BitstreamCursor &Cursor,
1215 assert(Offset != 0);
1218 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1219 Error(std::move(Err));
1227 Error(MaybeCode.takeError());
1230 unsigned Code = MaybeCode.get();
1233 if (!MaybeRecCode) {
1234 Error(MaybeRecCode.takeError());
1237 unsigned RecCode = MaybeRecCode.get();
1239 Error(
"Expected lexical block");
1243 assert(!isa<TranslationUnitDecl>(DC) &&
1244 "expected a TU_UPDATE_LEXICAL record for TU");
1249 auto &Lex = LexicalDecls[DC];
1251 Lex = std::make_pair(
1253 reinterpret_cast<const llvm::support::unaligned_uint32_t *
>(
1261bool ASTReader::ReadVisibleDeclContextStorage(
ModuleFile &M,
1262 BitstreamCursor &Cursor,
1265 assert(Offset != 0);
1268 if (llvm::Error Err =
Cursor.JumpToBit(Offset)) {
1269 Error(std::move(Err));
1277 Error(MaybeCode.takeError());
1280 unsigned Code = MaybeCode.get();
1283 if (!MaybeRecCode) {
1284 Error(MaybeRecCode.takeError());
1287 unsigned RecCode = MaybeRecCode.get();
1289 Error(
"Expected visible lookup table block");
1295 auto *
Data = (
const unsigned char*)Blob.data();
1296 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&M,
Data});
1300void ASTReader::Error(StringRef Msg)
const {
1301 Error(diag::err_fe_pch_malformed, Msg);
1302 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1303 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1304 Diag(diag::note_module_cache_path)
1305 << PP.getHeaderSearchInfo().getModuleCachePath();
1309void ASTReader::Error(
unsigned DiagID, StringRef Arg1, StringRef Arg2,
1310 StringRef Arg3)
const {
1311 if (Diags.isDiagnosticInFlight())
1312 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1314 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1317void ASTReader::Error(llvm::Error &&Err)
const {
1318 llvm::Error RemainingErr =
1325 assert(NumArgs <= 3 &&
"Can only have up to 3 arguments");
1326 StringRef Arg1, Arg2, Arg3;
1329 Arg3 =
Diag.getStringArg(2);
1332 Arg2 =
Diag.getStringArg(1);
1335 Arg1 =
Diag.getStringArg(0);
1337 Error(
Diag.getDiagID(), Arg1, Arg2, Arg3);
1348void ASTReader::ParseLineTable(
ModuleFile &F,
const RecordData &Record) {
1353 std::map<int, int> FileIDs;
1355 for (
unsigned I = 0;
Record[Idx]; ++I) {
1357 auto Filename = ReadPath(F, Record, Idx);
1363 std::vector<LineEntry> Entries;
1364 while (Idx <
Record.size()) {
1365 FileID FID = ReadFileID(F, Record, Idx);
1368 unsigned NumEntries =
Record[Idx++];
1369 assert(NumEntries &&
"no line entries for file ID");
1371 Entries.reserve(NumEntries);
1372 for (
unsigned I = 0; I != NumEntries; ++I) {
1373 unsigned FileOffset =
Record[Idx++];
1374 unsigned LineNo =
Record[Idx++];
1375 int FilenameID = FileIDs[
Record[Idx++]];
1378 unsigned IncludeOffset =
Record[Idx++];
1380 FileKind, IncludeOffset));
1387llvm::Error ASTReader::ReadSourceManagerBlock(
ModuleFile &F) {
1388 using namespace SrcMgr;
1396 SLocEntryCursor = F.
Stream;
1399 if (llvm::Error Err = F.
Stream.SkipBlock())
1410 SLocEntryCursor.advanceSkippingSubblocks();
1412 return MaybeE.takeError();
1413 llvm::BitstreamEntry E = MaybeE.get();
1416 case llvm::BitstreamEntry::SubBlock:
1417 case llvm::BitstreamEntry::Error:
1418 return llvm::createStringError(std::errc::illegal_byte_sequence,
1419 "malformed block record in AST file");
1420 case llvm::BitstreamEntry::EndBlock:
1421 return llvm::Error::success();
1422 case llvm::BitstreamEntry::Record:
1431 SLocEntryCursor.readRecord(E.ID, Record, &Blob);
1433 return MaybeRecord.takeError();
1434 switch (MaybeRecord.get()) {
1442 return llvm::Error::success();
1451 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1452 Error(
"source location entry ID out-of-range for AST file");
1458 auto ReadBuffer = [
this](
1459 BitstreamCursor &SLocEntryCursor,
1460 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1465 Error(MaybeCode.takeError());
1468 unsigned Code = MaybeCode.get();
1471 SLocEntryCursor.readRecord(Code, Record, &Blob);
1472 if (!MaybeRecCode) {
1473 Error(MaybeRecCode.takeError());
1476 unsigned RecCode = MaybeRecCode.get();
1481 const llvm::compression::Format F =
1482 Blob.size() > 0 && Blob.data()[0] == 0x78
1483 ? llvm::compression::Format::Zlib
1484 : llvm::compression::Format::Zstd;
1485 if (
const char *Reason = llvm::compression::getReasonIfUnsupported(F)) {
1490 if (llvm::Error E = llvm::compression::decompress(
1491 F, llvm::arrayRefFromStringRef(Blob), Decompressed, Record[0])) {
1492 Error(
"could not decompress embedded file contents: " +
1493 llvm::toString(std::move(E)));
1496 return llvm::MemoryBuffer::getMemBufferCopy(
1497 llvm::toStringRef(Decompressed), Name);
1499 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name,
true);
1501 Error(
"AST record has invalid code");
1506 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1510 Error(std::move(Err));
1517 ++NumSLocEntriesRead;
1520 Error(MaybeEntry.takeError());
1523 llvm::BitstreamEntry Entry = MaybeEntry.get();
1525 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1526 Error(
"incorrectly-formatted source location entry in AST file");
1533 SLocEntryCursor.readRecord(Entry.ID, Record, &Blob);
1535 Error(MaybeSLOC.takeError());
1538 switch (MaybeSLOC.get()) {
1540 Error(
"incorrectly-formatted source location entry in AST file");
1546 unsigned InputID = Record[4];
1547 InputFile IF = getInputFile(*F, InputID);
1560 IncludeLoc = getImportLocation(F);
1564 FileID FID = SourceMgr.createFileID(*
File, IncludeLoc, FileCharacter, ID,
1565 BaseOffset + Record[0]);
1568 FileInfo.NumCreatedFIDs = Record[5];
1572 unsigned NumFileDecls = Record[7];
1573 if (NumFileDecls && ContextObj) {
1575 assert(F->
FileSortedDecls &&
"FILE_SORTED_DECLS not encountered yet ?");
1581 SourceMgr.getOrCreateContentCache(*
File, isSystem(FileCharacter));
1585 auto Buffer = ReadBuffer(SLocEntryCursor,
File->getName());
1588 SourceMgr.overrideFileContents(*
File, std::move(Buffer));
1595 const char *Name = Blob.data();
1596 unsigned Offset = Record[0];
1601 IncludeLoc = getImportLocation(F);
1604 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1607 FileID FID = SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1608 BaseOffset + Offset, IncludeLoc);
1619 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1], Seq);
1620 SourceLocation ExpansionBegin = ReadSourceLocation(*F, Record[2], Seq);
1621 SourceLocation ExpansionEnd = ReadSourceLocation(*F, Record[3], Seq);
1622 SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
1623 Record[5], Record[4], ID,
1624 BaseOffset + Record[0]);
1636 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1637 Error(
"source location entry ID out-of-range for AST file");
1642 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1660 assert(SourceMgr.getMainFileID().isValid() &&
"missing main file");
1661 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1671 uint64_t *StartOfBlockOffset) {
1672 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID))
1675 if (StartOfBlockOffset)
1676 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1679 uint64_t Offset = Cursor.GetCurrentBitNo();
1682 return MaybeCode.takeError();
1683 unsigned Code = MaybeCode.get();
1686 if (Code != llvm::bitc::DEFINE_ABBREV) {
1687 if (llvm::Error Err = Cursor.JumpToBit(Offset))
1689 return llvm::Error::success();
1691 if (llvm::Error Err = Cursor.ReadAbbrevRecord())
1700 Tok.
setLocation(ReadSourceLocation(F, Record, Idx));
1707 case tok::annot_pragma_loop_hint: {
1709 Info->
PragmaName = ReadToken(F, Record, Idx);
1710 Info->Option = ReadToken(F, Record, Idx);
1711 unsigned NumTokens = Record[Idx++];
1713 Toks.reserve(NumTokens);
1714 for (
unsigned I = 0; I < NumTokens; ++I)
1715 Toks.push_back(ReadToken(F, Record, Idx));
1716 Info->Toks =
llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
1720 case tok::annot_pragma_pack: {
1723 auto SlotLabel = ReadString(Record, Idx);
1725 llvm::StringRef(SlotLabel).copy(PP.getPreprocessorAllocator());
1726 Info->Alignment = ReadToken(F, Record, Idx);
1731 case tok::annot_pragma_openmp:
1732 case tok::annot_pragma_openmp_end:
1733 case tok::annot_pragma_unused:
1736 llvm_unreachable(
"missing deserialization code for annotation token");
1753 if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1755 consumeError(std::move(Err));
1767 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1769 Stream.advanceSkippingSubblocks(Flags);
1771 Error(MaybeEntry.takeError());
1774 llvm::BitstreamEntry Entry = MaybeEntry.get();
1776 switch (Entry.Kind) {
1777 case llvm::BitstreamEntry::SubBlock:
1778 case llvm::BitstreamEntry::Error:
1779 Error(
"malformed block record in AST file");
1781 case llvm::BitstreamEntry::EndBlock:
1783 case llvm::BitstreamEntry::Record:
1794 Error(MaybeRecType.takeError());
1810 unsigned NextIndex = 1;
1812 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1817 PP.getPreprocessorAllocator());
1820 bool isC99VarArgs = Record[NextIndex++];
1821 bool isGNUVarArgs = Record[NextIndex++];
1822 bool hasCommaPasting = Record[NextIndex++];
1823 MacroParams.clear();
1824 unsigned NumArgs = Record[NextIndex++];
1825 for (
unsigned i = 0; i != NumArgs; ++i)
1826 MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1840 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1841 Record[NextIndex]) {
1844 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1846 PreprocessingRecord::PPEntityID PPID =
1847 PPRec.getPPEntityID(GlobalID - 1,
true);
1849 PPRec.getPreprocessedEntity(PPID));
1851 PPRec.RegisterMacroDefinition(Macro, PPDef);
1862 if (MacroTokens.empty()) {
1863 Error(
"unexpected number of macro tokens for a macro in AST file");
1868 MacroTokens[0] = ReadToken(F, Record, Idx);
1869 MacroTokens = MacroTokens.drop_front();
1878 unsigned LocalID)
const {
1880 ReadModuleOffsetMap(M);
1885 &&
"Invalid index into preprocessed entity index remap");
1887 return LocalID + I->second;
1890const FileEntry *HeaderFileInfoTrait::getFile(
const internal_key_type &Key) {
1892 if (!Key.Imported) {
1898 std::string Resolved = std::string(Key.Filename);
1899 Reader.ResolveImportedPath(M, Resolved);
1906 return llvm::hash_combine(ikey.
Size, ikey.
ModTime);
1927 return FEA && FEA == FEB;
1930std::pair<unsigned, unsigned>
1931HeaderFileInfoTrait::ReadKeyDataLength(
const unsigned char*& d) {
1936HeaderFileInfoTrait::ReadKey(
const unsigned char *d,
unsigned) {
1937 using namespace llvm::support;
1940 ikey.
Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1941 ikey.
ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1950 using namespace llvm::support;
1952 const unsigned char *End = d + DataLen;
1954 unsigned Flags = *d++;
1956 bool Included = (Flags >> 6) & 0x01;
1961 Reader.getPreprocessor().getIncludedFiles().insert(FE);
1964 HFI.
isImport |= (Flags >> 5) & 0x01;
1966 HFI.
DirInfo = (Flags >> 1) & 0x07;
1969 M, endian::readNext<uint32_t, little, unaligned>(d));
1970 if (
unsigned FrameworkOffset =
1971 endian::readNext<uint32_t, little, unaligned>(d)) {
1974 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1975 HFI.
Framework = HS->getUniqueFrameworkName(FrameworkName);
1978 assert((End - d) % 4 == 0 &&
1979 "Wrong data length in HeaderFileInfo deserialization");
1981 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1987 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1988 Module *Mod = Reader.getSubmodule(GlobalSMID);
1991 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1995 Reader.ResolveImportedPath(M,
Filename);
1999 ModMap.
addHeader(Mod, H, HeaderRole,
true);
2011 uint32_t MacroDirectivesOffset) {
2012 assert(NumCurrentElementsDeserializing > 0 &&
"Missing deserialization guard");
2013 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
2020 for (
ModuleFile &I : llvm::reverse(ModuleMgr)) {
2021 BitstreamCursor &MacroCursor = I.MacroCursor;
2024 if (MacroCursor.getBitcodeBytes().empty())
2027 BitstreamCursor Cursor = MacroCursor;
2028 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
2029 Error(std::move(Err));
2037 Error(MaybeE.takeError());
2040 llvm::BitstreamEntry E = MaybeE.get();
2043 case llvm::BitstreamEntry::SubBlock:
2044 case llvm::BitstreamEntry::Error:
2045 Error(
"malformed block record in AST file");
2047 case llvm::BitstreamEntry::EndBlock:
2050 case llvm::BitstreamEntry::Record: {
2054 Error(MaybeRecord.takeError());
2057 switch (MaybeRecord.get()) {
2065 updateOutOfDateIdentifier(*II);
2084 class IdentifierLookupVisitor {
2087 unsigned PriorGeneration;
2088 unsigned &NumIdentifierLookups;
2089 unsigned &NumIdentifierLookupHits;
2093 IdentifierLookupVisitor(StringRef Name,
unsigned PriorGeneration,
2094 unsigned &NumIdentifierLookups,
2095 unsigned &NumIdentifierLookupHits)
2097 PriorGeneration(PriorGeneration),
2098 NumIdentifierLookups(NumIdentifierLookups),
2099 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2113 ++NumIdentifierLookups;
2114 ASTIdentifierLookupTable::iterator Pos =
2115 IdTable->find_hashed(Name, NameHash, &Trait);
2116 if (Pos == IdTable->end())
2122 ++NumIdentifierLookupHits;
2138 unsigned PriorGeneration = 0;
2139 if (getContext().getLangOpts().Modules)
2140 PriorGeneration = IdentifierGeneration[&II];
2146 if (!loadGlobalIndex()) {
2147 if (GlobalIndex->lookupIdentifier(II.
getName(), Hits)) {
2152 IdentifierLookupVisitor Visitor(II.
getName(), PriorGeneration,
2153 NumIdentifierLookups,
2154 NumIdentifierLookupHits);
2155 ModuleMgr.visit(Visitor, HitsPtr);
2156 markIdentifierUpToDate(&II);
2166 if (getContext().getLangOpts().Modules)
2167 IdentifierGeneration[II] = getGeneration();
2171 const PendingMacroInfo &PMInfo) {
2176 if (llvm::Error Err =
2178 Error(std::move(Err));
2182 struct ModuleMacroRecord {
2195 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2197 Error(MaybeEntry.takeError());
2200 llvm::BitstreamEntry Entry = MaybeEntry.get();
2202 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2203 Error(
"malformed block record in AST file");
2210 Error(MaybePP.takeError());
2218 ModuleMacros.push_back(ModuleMacroRecord());
2219 auto &Info = ModuleMacros.back();
2220 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
2221 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
2222 for (
int I = 2, N = Record.size(); I != N; ++I)
2223 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2228 Error(
"malformed block record in AST file");
2239 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2241 for (
auto &MMR : ModuleMacros) {
2243 for (
unsigned ModID : MMR.Overrides) {
2244 Module *Mod = getSubmodule(ModID);
2245 auto *Macro = PP.getModuleMacro(Mod, II);
2246 assert(Macro &&
"missing definition for overridden macro");
2247 Overrides.push_back(Macro);
2250 bool Inserted =
false;
2251 Module *Owner = getSubmodule(MMR.SubModID);
2252 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2263 unsigned Idx = 0, N = Record.size();
2270 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2271 MD = PP.AllocateDefMacroDirective(MI, Loc);
2275 MD = PP.AllocateUndefMacroDirective(Loc);
2278 bool isPublic = Record[Idx++];
2279 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2291 PP.setLoadedMacroDirective(II, Earliest, Latest);
2294bool ASTReader::shouldDisableValidationForFile(
2332 consumeError(std::move(Err));
2338 consumeError(MaybeCode.takeError());
2340 unsigned Code = MaybeCode.get();
2346 "invalid record type for input file");
2349 consumeError(Maybe.takeError());
2352 assert(Record[0] == ID &&
"Bogus stored ID or offset");
2361 uint16_t AsRequestedLength =
Record[7];
2363 std::string NameAsRequested = Blob.substr(0, AsRequestedLength).str();
2364 std::string Name = Blob.substr(AsRequestedLength).str();
2366 ResolveImportedPath(F, NameAsRequested);
2367 ResolveImportedPath(F, Name);
2370 Name = NameAsRequested;
2372 return std::make_pair(std::move(NameAsRequested), std::move(Name));
2377 consumeError(MaybeEntry.takeError());
2378 llvm::BitstreamEntry Entry = MaybeEntry.get();
2379 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2380 "expected record type for input file hash");
2385 "invalid record type for input file hash");
2388 consumeError(Maybe.takeError());
2417 consumeError(std::move(Err));
2432 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2446 if ((Overridden || Transient || SkipChecks) && !
File)
2451 std::string ErrorStr =
"could not find file '";
2453 ErrorStr +=
"' referenced by AST file '";
2469 if ((!Overridden && !Transient) && !SkipChecks &&
SM.isFileOverridden(
File)) {
2483 enum ModificationKind {
2489 std::optional<int64_t> Old = std::nullopt;
2490 std::optional<int64_t> New = std::nullopt;
2492 auto HasInputContentChanged = [&](Change OriginalChange) {
2493 assert(ValidateASTInputFilesContent &&
2494 "We should only check the content of the inputs with "
2495 "ValidateASTInputFilesContent enabled.");
2497 if (StoredContentHash ==
static_cast<uint64_t>(llvm::hash_code(-1)))
2498 return OriginalChange;
2501 if (!MemBuffOrError) {
2503 return OriginalChange;
2504 std::string ErrorStr =
"could not get buffer for file '";
2505 ErrorStr +=
File->getName();
2508 return OriginalChange;
2512 auto ContentHash =
hash_value(MemBuffOrError.get()->getBuffer());
2513 if (StoredContentHash ==
static_cast<uint64_t>(ContentHash))
2514 return Change{Change::None};
2516 return Change{Change::Content};
2518 auto HasInputFileChanged = [&]() {
2519 if (StoredSize !=
File->getSize())
2520 return Change{Change::Size, StoredSize,
File->getSize()};
2521 if (!shouldDisableValidationForFile(F) && StoredTime &&
2522 StoredTime !=
File->getModificationTime()) {
2523 Change MTimeChange = {Change::ModTime, StoredTime,
2524 File->getModificationTime()};
2528 if (ValidateASTInputFilesContent)
2529 return HasInputContentChanged(MTimeChange);
2533 return Change{Change::None};
2536 bool IsOutOfDate =
false;
2537 auto FileChange = SkipChecks ? Change{Change::None} : HasInputFileChanged();
2543 FileChange = HasInputContentChanged(FileChange);
2546 if (!Overridden && FileChange.Kind != Change::None) {
2547 if (Complain && !Diags.isDiagnosticInFlight()) {
2550 while (!ImportStack.back()->ImportedBy.empty())
2551 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2554 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2555 Diag(diag::err_fe_ast_file_modified)
2557 << TopLevelPCHName << FileChange.Kind
2558 << (FileChange.Old && FileChange.New)
2559 << llvm::itostr(FileChange.Old.value_or(0))
2560 << llvm::itostr(FileChange.New.value_or(0));
2563 if (ImportStack.size() > 1) {
2564 Diag(diag::note_pch_required_by)
2565 <<
Filename << ImportStack[0]->FileName;
2566 for (
unsigned I = 1; I < ImportStack.size(); ++I)
2567 Diag(diag::note_pch_required_by)
2568 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2571 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2601 llvm::sys::path::append(Buffer, Prefix,
Filename);
2602 Filename.assign(Buffer.begin(), Buffer.end());
2617 llvm_unreachable(
"unknown ASTReadResult");
2621 BitstreamCursor &Stream,
unsigned ClientLoadCapabilities,
2623 std::string &SuggestedPredefines) {
2626 consumeError(std::move(Err));
2637 consumeError(MaybeEntry.takeError());
2640 llvm::BitstreamEntry Entry = MaybeEntry.get();
2642 switch (Entry.Kind) {
2643 case llvm::BitstreamEntry::Error:
2644 case llvm::BitstreamEntry::SubBlock:
2647 case llvm::BitstreamEntry::EndBlock:
2650 case llvm::BitstreamEntry::Record:
2658 if (!MaybeRecordType) {
2660 consumeError(MaybeRecordType.takeError());
2665 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2666 if (ParseLanguageOptions(Record, Complain, Listener,
2667 AllowCompatibleConfigurationMismatch))
2668 Result = ConfigurationMismatch;
2673 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2674 if (ParseTargetOptions(Record, Complain, Listener,
2675 AllowCompatibleConfigurationMismatch))
2676 Result = ConfigurationMismatch;
2681 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2682 if (!AllowCompatibleConfigurationMismatch &&
2683 ParseFileSystemOptions(Record, Complain, Listener))
2684 Result = ConfigurationMismatch;
2689 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2690 if (!AllowCompatibleConfigurationMismatch &&
2691 ParseHeaderSearchOptions(Record, Complain, Listener))
2692 Result = ConfigurationMismatch;
2697 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2698 if (!AllowCompatibleConfigurationMismatch &&
2699 ParsePreprocessorOptions(Record, Complain, Listener,
2700 SuggestedPredefines))
2701 Result = ConfigurationMismatch;
2711 unsigned ClientLoadCapabilities) {
2712 BitstreamCursor &Stream = F.
Stream;
2715 Error(std::move(Err));
2725 bool HasReadUnhashedControlBlock =
false;
2726 auto readUnhashedControlBlockOnce = [&]() {
2727 if (!HasReadUnhashedControlBlock) {
2728 HasReadUnhashedControlBlock =
true;
2729 if (ASTReadResult
Result =
2730 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2736 bool DisableValidation = shouldDisableValidationForFile(F);
2740 unsigned NumInputs = 0;
2741 unsigned NumUserInputs = 0;
2742 StringRef BaseDirectoryAsWritten;
2746 Error(MaybeEntry.takeError());
2749 llvm::BitstreamEntry Entry = MaybeEntry.get();
2751 switch (Entry.Kind) {
2752 case llvm::BitstreamEntry::Error:
2753 Error(
"malformed block record in AST file");
2755 case llvm::BitstreamEntry::EndBlock: {
2758 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2763 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2770 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2776 unsigned N = ValidateSystemInputs ? NumInputs : NumUserInputs;
2782 for (
unsigned I = 0; I < N; ++I) {
2783 InputFile IF = getInputFile(F, I+1, Complain);
2795 for (
unsigned I = 0; I < N; ++I) {
2796 bool IsSystem = I >= NumUserInputs;
2807 case llvm::BitstreamEntry::SubBlock:
2811 if (llvm::Error Err = Stream.SkipBlock()) {
2812 Error(std::move(Err));
2816 Error(
"malformed block record in AST file");
2826 if (Listener && !ImportedBy) {
2832 bool AllowCompatibleConfigurationMismatch =
2836 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2837 AllowCompatibleConfigurationMismatch, *Listener,
2838 SuggestedPredefines);
2840 Error(
"malformed block record in AST file");
2844 if (DisableValidation ||
2845 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
2853 }
else if (llvm::Error Err = Stream.SkipBlock()) {
2854 Error(std::move(Err));
2860 if (llvm::Error Err = Stream.SkipBlock()) {
2861 Error(std::move(Err));
2867 case llvm::BitstreamEntry::Record:
2876 Stream.readRecord(Entry.ID, Record, &Blob);
2877 if (!MaybeRecordType) {
2878 Error(MaybeRecordType.takeError());
2884 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2886 : diag::err_pch_version_too_new);
2890 bool hasErrors =
Record[7];
2891 if (hasErrors && !DisableValidation) {
2894 if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
2895 canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
2898 if (!AllowASTWithCompilerErrors) {
2899 Diag(diag::err_pch_with_compiler_errors);
2904 Diags.ErrorOccurred =
true;
2905 Diags.UncompilableErrorOccurred =
true;
2906 Diags.UnrecoverableErrorOccurred =
true;
2919 StringRef ASTBranch = Blob;
2920 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2921 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2922 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2932 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2936 unsigned Idx = 0, N =
Record.size();
2941 bool IsImportingStdCXXModule =
Record[Idx++];
2946 ReadUntranslatedSourceLocation(Record[Idx++]);
2947 off_t StoredSize = (off_t)Record[Idx++];
2948 time_t StoredModTime = (time_t)Record[Idx++];
2949 auto FirstSignatureByte =
Record.begin() + Idx;
2954 std::string ImportedName = ReadString(Record, Idx);
2955 std::string ImportedFile;
2964 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2965 ImportedName, !IsImportingStdCXXModule);
2967 if (ImportedFile.empty()) {
2970 if (IsImportingStdCXXModule)
2971 Diag(clang::diag::warn_reading_std_cxx_module_by_implicit_paths)
2976 ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2978 SkipPath(Record, Idx);
2982 unsigned Capabilities = ClientLoadCapabilities;
2983 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2984 Capabilities &= ~ARR_Missing;
2987 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2988 Loaded, StoredSize, StoredModTime,
2989 StoredSignature, Capabilities);
2992 bool recompilingFinalized =
2993 Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
2994 getModuleManager().getModuleCache().isPCMFinal(F.
FileName);
2996 Diag(diag::note_module_file_imported_by)
2998 if (recompilingFinalized)
2999 Diag(diag::note_module_file_conflict);
3002 case Failure:
return Failure;
3005 case OutOfDate:
return OutOfDate;
3007 case ConfigurationMismatch:
return ConfigurationMismatch;
3008 case HadErrors:
return HadErrors;
3028 Diag(diag::remark_module_import)
3030 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
3036 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3044 BaseDirectoryAsWritten = Blob;
3046 "MODULE_DIRECTORY found before MODULE_NAME");
3048 if (!PP.getPreprocessorOpts().ModulesCheckRelocated)
3052 Module *M = PP.getHeaderSearchInfo().lookupModule(
3059 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
3062 auto BuildDir = PP.getFileManager().getDirectory(Blob);
3063 if (!BuildDir || *BuildDir != M->
Directory) {
3064 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
3065 Diag(diag::err_imported_module_relocated)
3076 if (ASTReadResult
Result =
3077 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
3083 NumUserInputs =
Record[1];
3085 (
const llvm::support::unaligned_uint64_t *)Blob.data();
3094llvm::Error ASTReader::ReadASTBlock(
ModuleFile &F,
3095 unsigned ClientLoadCapabilities) {
3096 BitstreamCursor &Stream = F.
Stream;
3098 if (llvm::Error Err = Stream.EnterSubBlock(
AST_BLOCK_ID))
3107 return MaybeEntry.takeError();
3108 llvm::BitstreamEntry Entry = MaybeEntry.get();
3110 switch (Entry.Kind) {
3111 case llvm::BitstreamEntry::Error:
3112 return llvm::createStringError(
3113 std::errc::illegal_byte_sequence,
3114 "error at end of module block in AST file");
3115 case llvm::BitstreamEntry::EndBlock:
3127 return llvm::Error::success();
3128 case llvm::BitstreamEntry::SubBlock:
3136 if (llvm::Error Err = Stream.SkipBlock())
3138 if (llvm::Error Err = ReadBlockAbbrevs(
3145 if (!PP.getExternalSource())
3146 PP.setExternalSource(
this);
3148 if (llvm::Error Err = Stream.SkipBlock())
3150 if (llvm::Error Err =
3159 if (llvm::Error Err = Stream.SkipBlock()) {
3168 if (!PP.getPreprocessingRecord())
3169 PP.createPreprocessingRecord();
3170 if (!PP.getPreprocessingRecord()->getExternalSource())
3171 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3175 if (llvm::Error Err = ReadSourceManagerBlock(F))
3180 if (llvm::Error Err = ReadSubmoduleBlock(F, ClientLoadCapabilities))
3185 BitstreamCursor
C = Stream;
3187 if (llvm::Error Err = Stream.SkipBlock())
3191 CommentsCursors.push_back(std::make_pair(
C, &F));
3196 if (llvm::Error Err = Stream.SkipBlock())
3202 case llvm::BitstreamEntry::Record:
3211 Stream.readRecord(Entry.ID, Record, &Blob);
3212 if (!MaybeRecordType)
3213 return MaybeRecordType.takeError();
3246 return llvm::createStringError(
3247 std::errc::illegal_byte_sequence,
3248 "duplicate TYPE_OFFSET record in AST file");
3251 unsigned LocalBaseTypeIndex =
Record[1];
3256 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3260 std::make_pair(LocalBaseTypeIndex,
3270 return llvm::createStringError(
3271 std::errc::illegal_byte_sequence,
3272 "duplicate DECL_OFFSET record in AST file");
3275 unsigned LocalBaseDeclID =
Record[1];
3281 GlobalDeclMap.insert(
3287 std::make_pair(LocalBaseDeclID, F.
BaseDeclID - LocalBaseDeclID));
3299 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3300 LexicalContents Contents(
3301 reinterpret_cast<const llvm::support::unaligned_uint32_t *
>(
3303 static_cast<unsigned int>(Blob.size() / 4));
3304 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3312 auto *
Data = (
const unsigned char*)Blob.data();
3313 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&F,
Data});
3316 if (
Decl *D = GetExistingDecl(ID))
3317 PendingUpdateRecords.push_back(
3318 PendingUpdateRecord(ID, D,
false));
3324 reinterpret_cast<const unsigned char *
>(Blob.data());
3332 PP.getIdentifierTable().setExternalIdentifierLookup(
this);
3338 return llvm::createStringError(
3339 std::errc::illegal_byte_sequence,
3340 "duplicate IDENTIFIER_OFFSET record in AST file");
3343 unsigned LocalBaseIdentifierID =
Record[1];
3349 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3355 std::make_pair(LocalBaseIdentifierID,
3358 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3371 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3372 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3379 getContext().getLangOpts().BuildingPCHWithObjectFile)
3380 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3381 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3385 if (SpecialTypes.empty()) {
3386 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3387 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
3391 if (SpecialTypes.size() !=
Record.size())
3392 return llvm::createStringError(std::errc::illegal_byte_sequence,
3393 "invalid special-types record");
3395 for (
unsigned I = 0, N =
Record.size(); I != N; ++I) {
3397 if (!SpecialTypes[I])
3398 SpecialTypes[I] =
ID;
3405 TotalNumStatements +=
Record[0];
3406 TotalNumMacros +=
Record[1];
3407 TotalLexicalDeclContexts +=
Record[2];
3408 TotalVisibleDeclContexts +=
Record[3];
3412 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3413 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
3417 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3418 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3422 if (
Record.size() % 3 != 0)
3423 return llvm::createStringError(std::errc::illegal_byte_sequence,
3424 "invalid weak identifiers record");
3428 WeakUndeclaredIdentifiers.clear();
3431 for (
unsigned I = 0, N =
Record.size(); I < N; ) {
3432 WeakUndeclaredIdentifiers.push_back(
3433 getGlobalIdentifierID(F, Record[I++]));
3434 WeakUndeclaredIdentifiers.push_back(
3435 getGlobalIdentifierID(F, Record[I++]));
3436 WeakUndeclaredIdentifiers.push_back(
3437 ReadSourceLocation(F, Record, I).getRawEncoding());
3444 unsigned LocalBaseSelectorID =
Record[1];
3450 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3455 std::make_pair(LocalBaseSelectorID,
3467 = ASTSelectorLookupTable::Create(
3471 TotalNumMethodPoolEntries +=
Record[1];
3476 for (
unsigned Idx = 0, N =
Record.size() - 1; Idx < N; ) {
3477 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3479 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3488 PP.setPreambleRecordedPragmaAssumeNonNullLoc(
3489 ReadSourceLocation(F, Record, Idx));
3495 unsigned Idx = 0, End =
Record.size() - 1;
3496 bool ReachedEOFWhileSkipping =
Record[Idx++];
3497 std::optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3498 if (ReachedEOFWhileSkipping) {
3501 bool FoundNonSkipPortion =
Record[Idx++];
3502 bool FoundElse =
Record[Idx++];
3504 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3505 FoundElse, ElseLoc);
3509 auto Loc = ReadSourceLocation(F, Record, Idx);
3510 bool WasSkipping =
Record[Idx++];
3511 bool FoundNonSkip =
Record[Idx++];
3512 bool FoundElse =
Record[Idx++];
3513 ConditionalStack.push_back(
3514 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3516 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3521 if (!
Record.empty() && Listener)
3539 if (!Diags.isDiagnosticInFlight()) {
3541 SourceMgr.noteSLocAddressSpaceUsage(Diags);
3543 return llvm::createStringError(std::errc::invalid_argument,
3544 "ran out of source locations");
3549 unsigned RangeStart =
3551 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3556 GlobalSLocOffsetMap.insert(
3558 - SLocSpaceSize,&F));
3576 ParseLineTable(F, Record);
3583 return llvm::createStringError(
3584 std::errc::illegal_byte_sequence,
3585 "Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3592 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3593 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3597 if (
Record.size() % 3 != 0)
3598 return llvm::createStringError(std::errc::illegal_byte_sequence,
3599 "Invalid VTABLE_USES record");
3606 for (
unsigned Idx = 0, N =
Record.size(); Idx != N; ) {
3607 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3608 VTableUses.push_back(
3609 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3610 VTableUses.push_back(Record[Idx++]);
3615 if (PendingInstantiations.size() % 2 != 0)
3616 return llvm::createStringError(
3617 std::errc::illegal_byte_sequence,
3618 "Invalid existing PendingInstantiations");
3620 if (
Record.size() % 2 != 0)
3621 return llvm::createStringError(
3622 std::errc::illegal_byte_sequence,
3623 "Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3625 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3626 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3627 PendingInstantiations.push_back(
3628 ReadSourceLocation(F, Record, I).getRawEncoding());
3634 return llvm::createStringError(std::errc::illegal_byte_sequence,
3635 "Invalid SEMA_DECL_REFS block");
3636 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3637 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3645 unsigned LocalBasePreprocessedEntityID =
Record[0];
3647 unsigned StartingID;
3648 if (!PP.getPreprocessingRecord())
3649 PP.createPreprocessingRecord();
3650 if (!PP.getPreprocessingRecord()->getExternalSource())
3651 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3653 = PP.getPreprocessingRecord()
3660 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3665 std::make_pair(LocalBasePreprocessedEntityID,
3677 if (!PP.getPreprocessingRecord())
3678 PP.createPreprocessingRecord();
3679 if (!PP.getPreprocessingRecord()->getExternalSource())
3680 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3685 GlobalSkippedRangeMap.insert(
3691 if (
Record.size() % 2 != 0)
3692 return llvm::createStringError(
3693 std::errc::illegal_byte_sequence,
3694 "invalid DECL_UPDATE_OFFSETS block in AST file");
3695 for (
unsigned I = 0, N =
Record.size(); I != N; I += 2) {
3697 DeclUpdateOffsets[
ID].push_back(std::make_pair(&F, Record[I + 1]));
3701 if (
Decl *D = GetExistingDecl(ID))
3702 PendingUpdateRecords.push_back(
3703 PendingUpdateRecord(ID, D,
false));
3709 return llvm::createStringError(
3710 std::errc::illegal_byte_sequence,
3711 "duplicate OBJC_CATEGORIES_MAP record in AST file");
3724 CUDASpecialDeclRefs.clear();
3725 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3726 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3734 = HeaderFileInfoLookupTable::Create(
3738 &PP.getHeaderSearchInfo(),
3739 Blob.data() + Record[2]));
3741 PP.getHeaderSearchInfo().SetExternalSource(
this);
3742 if (!PP.getHeaderSearchInfo().getExternalLookup())
3743 PP.getHeaderSearchInfo().SetExternalLookup(
this);
3749 FPPragmaOptions.swap(Record);
3753 for (
unsigned I = 0, E =
Record.size(); I != E; ) {
3754 auto Name = ReadString(Record, I);
3755 auto &OptInfo = OpenCLExtensions.OptMap[Name];
3756 OptInfo.Supported =
Record[I++] != 0;
3757 OptInfo.Enabled =
Record[I++] != 0;
3758 OptInfo.WithPragma =
Record[I++] != 0;
3759 OptInfo.Avail =
Record[I++];
3760 OptInfo.Core =
Record[I++];
3761 OptInfo.Opt =
Record[I++];
3766 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3767 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3771 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3772 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3776 if (UndefinedButUsed.size() % 2 != 0)
3777 return llvm::createStringError(std::errc::illegal_byte_sequence,
3778 "Invalid existing UndefinedButUsed");
3780 if (
Record.size() % 2 != 0)
3781 return llvm::createStringError(std::errc::illegal_byte_sequence,
3782 "invalid undefined-but-used record");
3783 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3784 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3785 UndefinedButUsed.push_back(
3786 ReadSourceLocation(F, Record, I).getRawEncoding());
3791 for (
unsigned I = 0, N =
Record.size(); I != N;) {
3792 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3794 DelayedDeleteExprs.push_back(Count);
3795 for (uint64_t
C = 0;
C < Count; ++
C) {
3796 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3797 bool IsArrayForm =
Record[I++] == 1;
3798 DelayedDeleteExprs.push_back(IsArrayForm);
3808 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3809 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3812 PendingImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3813 if (DeserializationListener)
3814 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3822 return llvm::createStringError(
3823 std::errc::illegal_byte_sequence,
3824 "duplicate MACRO_OFFSET record in AST file");
3827 unsigned LocalBaseMacroID =
Record[1];
3833 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3837 std::make_pair(LocalBaseMacroID,
3846 LateParsedTemplates.emplace_back(
3847 std::piecewise_construct, std::forward_as_tuple(&F),
3853 return llvm::createStringError(std::errc::illegal_byte_sequence,
3854 "invalid pragma optimize record");
3855 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3860 return llvm::createStringError(std::errc::illegal_byte_sequence,
3861 "invalid pragma ms_struct record");
3862 PragmaMSStructState =
Record[0];
3867 return llvm::createStringError(
3868 std::errc::illegal_byte_sequence,
3869 "invalid pragma pointers to members record");
3870 PragmaMSPointersToMembersState =
Record[0];
3871 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3875 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3876 UnusedLocalTypedefNameCandidates.push_back(
3877 getGlobalDeclID(F, Record[I]));
3882 return llvm::createStringError(std::errc::illegal_byte_sequence,
3883 "invalid cuda pragma options record");
3884 ForceCUDAHostDeviceDepth =
Record[0];
3889 return llvm::createStringError(std::errc::illegal_byte_sequence,
3890 "invalid pragma pack record");
3891 PragmaAlignPackCurrentValue = ReadAlignPackInfo(Record[0]);
3892 PragmaAlignPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3893 unsigned NumStackEntries =
Record[2];
3896 PragmaAlignPackStack.clear();
3897 for (
unsigned I = 0; I < NumStackEntries; ++I) {
3898 PragmaAlignPackStackEntry Entry;
3899 Entry.Value = ReadAlignPackInfo(Record[Idx++]);
3900 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3901 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3902 PragmaAlignPackStrings.push_back(ReadString(Record, Idx));
3903 Entry.SlotLabel = PragmaAlignPackStrings.back();
3904 PragmaAlignPackStack.push_back(Entry);
3911 return llvm::createStringError(std::errc::illegal_byte_sequence,
3912 "invalid pragma float control record");
3914 FpPragmaCurrentLocation = ReadSourceLocation(F, Record[1]);
3915 unsigned NumStackEntries =
Record[2];
3918 FpPragmaStack.clear();
3919 for (
unsigned I = 0; I < NumStackEntries; ++I) {
3920 FpPragmaStackEntry Entry;
3922 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3923 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3924 FpPragmaStrings.push_back(ReadString(Record, Idx));
3925 Entry.SlotLabel = FpPragmaStrings.back();
3926 FpPragmaStack.push_back(Entry);
3932 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3933 DeclsToCheckForDeferredDiags.insert(getGlobalDeclID(F, Record[I]));
3939void ASTReader::ReadModuleOffsetMap(
ModuleFile &F)
const {
3954 using SLocRemapBuilder =
3967 while (
Data < DataEnd) {
3971 using namespace llvm::support;
3973 endian::readNext<uint8_t, little, unaligned>(
Data));
3974 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(
Data);
3975 StringRef Name = StringRef((
const char*)
Data, Len);
3979 ? ModuleMgr.lookupByModuleName(Name)
3980 : ModuleMgr.lookupByFileName(Name));
3983 "SourceLocation remap refers to unknown module, cannot find ";
3984 Msg.append(std::string(Name));
3990 endian::readNext<uint32_t, little, unaligned>(
Data);
3991 uint32_t IdentifierIDOffset =
3992 endian::readNext<uint32_t, little, unaligned>(
Data);
3993 uint32_t MacroIDOffset =
3994 endian::readNext<uint32_t, little, unaligned>(
Data);
3995 uint32_t PreprocessedEntityIDOffset =
3996 endian::readNext<uint32_t, little, unaligned>(
Data);
3997 uint32_t SubmoduleIDOffset =
3998 endian::readNext<uint32_t, little, unaligned>(
Data);
3999 uint32_t SelectorIDOffset =
4000 endian::readNext<uint32_t, little, unaligned>(
Data);
4001 uint32_t DeclIDOffset =
4002 endian::readNext<uint32_t, little, unaligned>(
Data);
4003 uint32_t TypeIndexOffset =
4004 endian::readNext<uint32_t, little, unaligned>(
Data);
4006 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
4007 RemapBuilder &Remap) {
4008 constexpr uint32_t
None = std::numeric_limits<uint32_t>::max();
4010 Remap.insert(std::make_pair(Offset,
4011 static_cast<int>(BaseOffset - Offset)));
4015 std::numeric_limits<SourceLocation::UIntTy>::max();
4016 if (SLocOffset != SLocNone)
4022 mapOffset(MacroIDOffset, OM->
BaseMacroID, MacroRemap);
4024 PreprocessedEntityRemap);
4027 mapOffset(DeclIDOffset, OM->
BaseDeclID, DeclRemap);
4036ASTReader::ReadModuleMapFileBlock(RecordData &Record,
ModuleFile &F,
4038 unsigned ClientLoadCapabilities) {
4047 "MODULE_NAME should come before MODULE_MAP_FILE");
4048 if (PP.getPreprocessorOpts().ModulesCheckRelocated &&
4054 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
4056 M ? Map.getModuleMapFileForUniquing(M) : std::nullopt;
4058 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
4061 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities)) {
4062 if (
auto ASTFE = M ? M->
getASTFile() : std::nullopt) {
4065 << ASTFE->getName();
4068 Diag(diag::err_imported_module_not_found)
4076 Diag(diag::note_imported_by_pch_module_not_found)
4083 assert(M && M->
Name == F.
ModuleName &&
"found module with different name");
4087 if (!StoredModMap || *StoredModMap != ModMap) {
4088 assert(ModMap &&
"found module is missing module map file");
4090 "top-level import should be verified");
4092 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4093 Diag(diag::err_imported_module_modmap_changed)
4100 for (
unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
4102 std::string
Filename = ReadPath(F, Record, Idx);
4105 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4106 Error(
"could not find file '" +
Filename +
"' referenced by AST file");
4109 AdditionalStoredMaps.insert(*SF);
4114 if (
auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
4118 if (!AdditionalStoredMaps.erase(ModMap)) {
4119 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4120 Diag(diag::err_module_different_modmap)
4130 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4131 Diag(diag::err_module_different_modmap)
4152 : Known->second.second;
4154 for (
ObjCMethodList *List = &Start; List; List = List->getNext()) {
4156 if (List->getMethod() == Method) {
4164 if (List->getNext())
4165 List->setMethod(List->getNext()->getMethod());
4167 List->setMethod(Method);
4173 for (
Decl *D : Names) {
4174 bool wasHidden = !D->isUnconditionallyVisible();
4175 D->setVisibleDespiteOwningModule();
4177 if (wasHidden && SemaObj) {
4190 Stack.push_back(Mod);
4191 while (!Stack.empty()) {
4192 Mod = Stack.pop_back_val();
4194 if (NameVisibility <= Mod->NameVisibility) {
4210 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4211 if (Hidden != HiddenNamesMap.end()) {
4213 HiddenNamesMap.erase(Hidden);
4215 assert(!HiddenNamesMap.contains(Mod) &&
4216 "making names visible added hidden names");
4223 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4225 if (
Visited.insert(Exported).second)
4226 Stack.push_back(Exported);
4241 getContext().mergeDefinitionIntoModule(
4244 PendingMergedDefinitionsToDeduplicate.insert(Def);
4253 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4254 !PP.getLangOpts().Modules)
4258 TriedLoadingGlobalIndex =
true;
4259 StringRef ModuleCachePath
4260 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4261 std::pair<GlobalModuleIndex *, llvm::Error>
Result =
4263 if (llvm::Error Err = std::move(
Result.second)) {
4265 consumeError(std::move(Err));
4269 GlobalIndex.reset(
Result.first);
4270 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4275 return PP.getLangOpts().Modules && UseGlobalIndex &&
4276 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4283 llvm::raw_fd_ostream OS(TimestampFilename, EC,
4284 llvm::sys::fs::OF_TextWithCRLF);
4287 OS <<
"Timestamp file\n";
4300 consumeError(MaybeEntry.takeError());
4303 llvm::BitstreamEntry Entry = MaybeEntry.get();
4305 switch (Entry.Kind) {
4306 case llvm::BitstreamEntry::Error:
4307 case llvm::BitstreamEntry::EndBlock:
4310 case llvm::BitstreamEntry::Record:
4316 consumeError(Skipped.takeError());
4320 case llvm::BitstreamEntry::SubBlock:
4321 if (Entry.ID == BlockID) {
4322 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4324 consumeError(std::move(Err));
4331 if (llvm::Error Err = Cursor.SkipBlock()) {
4333 consumeError(std::move(Err));
4342 unsigned ClientLoadCapabilities,
4344 llvm::TimeTraceScope scope(
"ReadAST", FileName);
4348 CurrentDeserializingModuleKind,
Type);
4354 unsigned PreviousGeneration = 0;
4356 PreviousGeneration = incrementGeneration(*ContextObj);
4358 unsigned NumModules = ModuleMgr.size();
4361 ReadASTCore(FileName,
Type, ImportLoc,
4363 ClientLoadCapabilities)) {
4364 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules);
4368 GlobalIndex.reset();
4369 ModuleMgr.setGlobalIndex(
nullptr);
4373 if (NewLoadedModuleFile && !Loaded.empty())
4374 *NewLoadedModuleFile = Loaded.back().Mod;
4385 for (ImportedModule &M : Loaded) {
4387 llvm::TimeTraceScope Scope2(
"Read Loaded AST", F.
ModuleName);
4390 if (llvm::Error Err = ReadASTBlock(F, ClientLoadCapabilities)) {
4391 Error(std::move(Err));
4397 Error(diag::err_module_file_missing_top_level_submodule, F.
FileName);
4403 if (llvm::Error Err = ReadExtensionBlock(F)) {
4404 Error(std::move(Err));
4417 for (ImportedModule &M : Loaded) {
4427 SourceMgr.getLoadedSLocEntryByID(Index);
4443 if (!PP.getLangOpts().CPlusPlus) {
4450 auto It = PP.getIdentifierTable().find(Key);
4451 if (It == PP.getIdentifierTable().end())
4460 II = &PP.getIdentifierTable().getOwn(Key);
4471 SetIdentifierInfo(ID, II);
4478 for (
auto &
Id : PP.getIdentifierTable())
4479 Id.second->setOutOfDate(
true);
4482 for (
const auto &Sel : SelectorGeneration)
4483 SelectorOutOfDate[Sel.first] =
true;
4487 for (ImportedModule &M : Loaded) {
4490 ModuleMgr.moduleFileAccepted(&F);
4499 F.
ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4503 for (
unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4504 UnresolvedModuleRef &
Unresolved = UnresolvedModuleRefs[I];
4506 Module *ResolvedMod = getSubmodule(GlobalID);
4509 case UnresolvedModuleRef::Conflict:
4512 Conflict.
Other = ResolvedMod;
4514 Unresolved.Mod->Conflicts.push_back(Conflict);
4518 case UnresolvedModuleRef::Import:
4523 case UnresolvedModuleRef::Affecting:
4525 Unresolved.Mod->AffectingClangModules.insert(ResolvedMod);
4528 case UnresolvedModuleRef::Export:
4535 UnresolvedModuleRefs.clear();
4542 InitializeContext();
4547 if (DeserializationListener)
4548 DeserializationListener->ReaderInitialized(
this);
4550 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4565 for (
unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4566 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4567 ObjCClassesLoaded[I],
4568 PreviousGeneration);
4577 for (
unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4578 ImportedModule &M = Loaded[I];
4595 if (!Stream.canSkipToPos(4))
4596 return llvm::createStringError(std::errc::illegal_byte_sequence,
4597 "file too small to contain AST file magic");
4598 for (
unsigned C : {
'C',
'P',
'C',
'H'})
4601 return llvm::createStringError(
4602 std::errc::illegal_byte_sequence,
4603 "file doesn't start with AST file magic");
4605 return Res.takeError();
4606 return llvm::Error::success();
4621 llvm_unreachable(
"unknown module kind");
4625ASTReader::ReadASTCore(StringRef FileName,
4630 off_t ExpectedSize, time_t ExpectedModTime,
4632 unsigned ClientLoadCapabilities) {
4634 std::string ErrorStr;
4636 = ModuleMgr.addModule(FileName,
Type, ImportLoc, ImportedBy,
4637 getGeneration(), ExpectedSize, ExpectedModTime,
4641 switch (AddResult) {
4643 Diag(diag::remark_module_import)
4645 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
4655 if (ClientLoadCapabilities & ARR_Missing)
4659 Diag(diag::err_ast_file_not_found)
4667 if (ClientLoadCapabilities & ARR_OutOfDate)
4671 Diag(diag::err_ast_file_out_of_date)
4677 assert(M &&
"Missing module file");
4679 bool ShouldFinalizePCM =
false;
4680 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4681 auto &MC = getModuleManager().getModuleCache();
4682 if (ShouldFinalizePCM)
4683 MC.finalizePCM(FileName);
4685 MC.tryToDropPCM(FileName);
4688 BitstreamCursor &Stream = F.
Stream;
4689 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4690 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4694 Diag(diag::err_ast_file_invalid)
4700 bool HaveReadControlBlock =
false;
4704 Error(MaybeEntry.takeError());
4707 llvm::BitstreamEntry Entry = MaybeEntry.get();
4709 switch (Entry.Kind) {
4710 case llvm::BitstreamEntry::Error:
4711 case llvm::BitstreamEntry::Record:
4712 case llvm::BitstreamEntry::EndBlock:
4713 Error(
"invalid record at top-level of AST file");
4716 case llvm::BitstreamEntry::SubBlock:
4722 HaveReadControlBlock =
true;
4723 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4731 F.ModuleName.empty()) {
4733 if (
Result != OutOfDate ||
4734 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4735 Diag(diag::err_module_file_not_module) << FileName;
4740 case Failure:
return Failure;
4741 case Missing:
return Missing;
4742 case OutOfDate:
return OutOfDate;
4744 case ConfigurationMismatch:
return ConfigurationMismatch;
4745 case HadErrors:
return HadErrors;
4750 if (!HaveReadControlBlock) {
4751 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4752 Diag(diag::err_pch_version_too_old);
4757 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4758 ShouldFinalizePCM =
true;
4762 if (llvm::Error Err = Stream.SkipBlock()) {
4763 Error(std::move(Err));
4770 llvm_unreachable(
"unexpected break; expected return");
4774ASTReader::readUnhashedControlBlock(
ModuleFile &F,
bool WasImportedBy,
4775 unsigned ClientLoadCapabilities) {
4777 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4778 bool AllowCompatibleConfigurationMismatch =
4780 bool DisableValidation = shouldDisableValidationForFile(F);
4782 ASTReadResult
Result = readUnhashedControlBlockImpl(
4783 &F, F.
Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4789 if (DisableValidation || WasImportedBy ||
4790 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
4794 Error(
"malformed block record in AST file");
4817 if (getModuleManager().getModuleCache().isPCMFinal(F.
FileName)) {
4818 Diag(diag::warn_module_system_bit_conflict) << F.
FileName;
4827 ModuleFile *F, llvm::StringRef StreamData,
unsigned ClientLoadCapabilities,
4829 bool ValidateDiagnosticOptions) {
4831 BitstreamCursor Stream(StreamData);
4836 consumeError(std::move(Err));
4851 consumeError(MaybeEntry.takeError());
4854 llvm::BitstreamEntry Entry = MaybeEntry.get();
4856 switch (Entry.Kind) {
4857 case llvm::BitstreamEntry::Error:
4858 case llvm::BitstreamEntry::SubBlock:
4861 case llvm::BitstreamEntry::EndBlock:
4864 case llvm::BitstreamEntry::Record:
4873 Stream.readRecord(Entry.ID, Record, &Blob);
4874 if (!MaybeRecordType) {
4883 "Dummy AST file signature not backpatched in ASTWriter.");
4890 "Dummy AST block hash not backpatched in ASTWriter.");
4894 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4895 if (Listener && ValidateDiagnosticOptions &&
4896 !AllowCompatibleConfigurationMismatch &&
4897 ParseDiagnosticOptions(Record, Complain, *Listener))
4902 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
4903 if (!AllowCompatibleConfigurationMismatch &&
4904 ParseHeaderSearchPaths(Record, Complain, *Listener))
4905 Result = ConfigurationMismatch;
4920 unsigned Count =
Record[0];
4921 const char *Byte = Blob.data();
4923 for (
unsigned I = 0; I < Count; ++Byte)
4924 for (
unsigned Bit = 0; Bit < 8 && I < Count; ++Bit, ++I)
4925 if (*Byte & (1 << Bit))
4937 if (Record.size() < 4)
return true;
4942 unsigned BlockNameLen = Record[2];
4943 unsigned UserInfoLen = Record[3];
4945 if (BlockNameLen + UserInfoLen > Blob.size())
return true;
4947 Metadata.
BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4948 Metadata.
UserInfo = std::string(Blob.data() + BlockNameLen,
4949 Blob.data() + BlockNameLen + UserInfoLen);
4953llvm::Error ASTReader::ReadExtensionBlock(
ModuleFile &F) {
4954 BitstreamCursor &Stream = F.
Stream;
4960 return MaybeEntry.takeError();
4961 llvm::BitstreamEntry Entry = MaybeEntry.get();
4963 switch (Entry.Kind) {
4964 case llvm::BitstreamEntry::SubBlock:
4965 if (llvm::Error Err = Stream.SkipBlock())
4968 case llvm::BitstreamEntry::EndBlock:
4969 return llvm::Error::success();
4970 case llvm::BitstreamEntry::Error:
4971 return llvm::createStringError(std::errc::illegal_byte_sequence,
4972 "malformed block record in AST file");
4973 case llvm::BitstreamEntry::Record:
4980 Stream.readRecord(Entry.ID, Record, &Blob);
4982 return MaybeRecCode.takeError();
4983 switch (MaybeRecCode.get()) {
4987 return llvm::createStringError(
4988 std::errc::illegal_byte_sequence,
4989 "malformed EXTENSION_METADATA in AST file");
4992 auto Known = ModuleFileExtensions.find(Metadata.
BlockName);
4993 if (Known == ModuleFileExtensions.end())
break;
4996 if (
auto Reader = Known->second->createExtensionReader(Metadata, *
this,
5006 return llvm::Error::success();
5010 assert(ContextObj &&
"no context to initialize");
5014 if (DeserializationListener)
5024 if (!Context.CFConstantStringTypeDecl)
5031 Error(
"FILE type is NULL");
5035 if (!Context.FILEDecl) {
5041 Error(
"Invalid FILE type in AST file");
5050 QualType Jmp_bufType = GetType(Jmp_buf);
5051 if (Jmp_bufType.
isNull()) {
5052 Error(
"jmp_buf type is NULL");
5056 if (!Context.jmp_bufDecl) {
5062 Error(
"Invalid jmp_buf type in AST file");
5071 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
5072 if (Sigjmp_bufType.
isNull()) {
5073 Error(
"sigjmp_buf type is NULL");
5077 if (!Context.sigjmp_bufDecl) {
5082 assert(Tag &&
"Invalid sigjmp_buf type in AST file");
5088 if (
unsigned ObjCIdRedef
5090 if (Context.ObjCIdRedefinitionType.
isNull())
5091 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
5094 if (
unsigned ObjCClassRedef
5096 if (Context.ObjCClassRedefinitionType.
isNull())
5097 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
5100 if (
unsigned ObjCSelRedef
5102 if (Context.ObjCSelRedefinitionType.
isNull())
5103 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
5107 QualType Ucontext_tType = GetType(Ucontext_t);
5108 if (Ucontext_tType.
isNull()) {
5109 Error(
"ucontext_t type is NULL");
5113 if (!Context.ucontext_tDecl) {
5118 assert(Tag &&
"Invalid ucontext_t type in AST file");
5128 if (!CUDASpecialDeclRefs.empty()) {
5129 assert(CUDASpecialDeclRefs.size() == 1 &&
"More decl refs than expected!");
5131 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5136 for (
auto &Import : PendingImportedModules) {
5137 if (
Module *Imported = getSubmodule(Import.ID)) {
5140 if (Import.ImportLoc.isValid())
5141 PP.makeModuleVisible(Imported, Import.ImportLoc);
5148 PendingImportedModulesSema.append(PendingImportedModules);
5149 PendingImportedModules.clear();
5159 BitstreamCursor Stream(
PCH);
5162 consumeError(std::move(Err));
5174 Stream.advanceSkippingSubblocks();
5177 consumeError(MaybeEntry.takeError());
5180 llvm::BitstreamEntry Entry = MaybeEntry.get();
5182 if (Entry.Kind != llvm::BitstreamEntry::Record)
5190 consumeError(MaybeRecord.takeError());
5196 "Dummy AST file signature not backpatched in ASTWriter.");
5206 const std::string &ASTFileName,
FileManager &FileMgr,
5212 Diags.
Report(diag::err_fe_unable_to_read_pch_file)
5213 << ASTFileName << Buffer.getError().message();
5214 return std::string();
5218 BitstreamCursor Stream(PCHContainerRdr.
ExtractPCH(**Buffer));
5222 Diags.
Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5223 return std::string();
5228 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5229 return std::string();
5236 Stream.advanceSkippingSubblocks();
5239 consumeError(MaybeEntry.takeError());
5240 return std::string();
5242 llvm::BitstreamEntry Entry = MaybeEntry.get();
5244 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5245 return std::string();
5247 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5248 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5249 return std::string();
5257 consumeError(MaybeRecord.takeError());
5258 return std::string();
5271 std::string ExistingModuleCachePath;
5273 bool StrictOptionMatches;
5276 SimplePCHValidator(
const LangOptions &ExistingLangOpts,
5279 StringRef ExistingModuleCachePath,
FileManager &FileMgr,
5280 bool StrictOptionMatches)
5281 : ExistingLangOpts(ExistingLangOpts),
5282 ExistingTargetOpts(ExistingTargetOpts),
5283 ExistingPPOpts(ExistingPPOpts),
5284 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr),
5285 StrictOptionMatches(StrictOptionMatches) {}
5287 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
5288 bool AllowCompatibleDifferences)
override {
5290 AllowCompatibleDifferences);
5293 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
5294 bool AllowCompatibleDifferences)
override {
5296 AllowCompatibleDifferences);
5300 StringRef SpecificModuleCachePath,
5301 bool Complain)
override {
5303 ExistingModuleCachePath,
nullptr,
5304 ExistingLangOpts, ExistingPPOpts);
5308 bool ReadMacros,
bool Complain,
5309 std::string &SuggestedPredefines)
override {
5311 PPOpts, ExistingPPOpts, ReadMacros,
nullptr, FileMgr,
5312 SuggestedPredefines, ExistingLangOpts,
5326 std::unique_ptr<llvm::MemoryBuffer> OwnedBuffer;
5338 OwnedBuffer = std::move(*BufferOrErr);
5339 Buffer = OwnedBuffer.get();
5343 StringRef Bytes = PCHContainerRdr.
ExtractPCH(*Buffer);
5344 BitstreamCursor Stream(Bytes);
5348 consumeError(std::move(Err));
5359 BitstreamCursor InputFilesCursor;
5360 uint64_t InputFilesOffsetBase = 0;
5363 std::string ModuleDir;
5364 bool DoneWithControlBlock =
false;
5365 while (!DoneWithControlBlock) {
5369 consumeError(MaybeEntry.takeError());
5372 llvm::BitstreamEntry Entry = MaybeEntry.get();
5374 switch (Entry.Kind) {
5375 case llvm::BitstreamEntry::SubBlock: {
5378 std::string IgnoredSuggestedPredefines;
5379 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
5381 Listener, IgnoredSuggestedPredefines) != Success)
5387 InputFilesCursor = Stream;
5388 if (llvm::Error Err = Stream.SkipBlock()) {
5390 consumeError(std::move(Err));
5393 if (NeedsInputFiles &&
5396 InputFilesOffsetBase = InputFilesCursor.GetCurrentBitNo();
5400 if (llvm::Error Err = Stream.SkipBlock()) {
5402 consumeError(std::move(Err));
5411 case llvm::BitstreamEntry::EndBlock:
5412 DoneWithControlBlock =
true;
5415 case llvm::BitstreamEntry::Error:
5418 case llvm::BitstreamEntry::Record:
5422 if (DoneWithControlBlock)
break;
5427 Stream.readRecord(Entry.ID, Record, &Blob);
5428 if (!MaybeRecCode) {
5443 ModuleDir = std::string(Blob);
5447 auto Path = ReadString(Record, Idx);
5448 ResolveImportedPath(Path, ModuleDir);