94#include "llvm/ADT/APFloat.h"
95#include "llvm/ADT/APInt.h"
96#include "llvm/ADT/APSInt.h"
97#include "llvm/ADT/ArrayRef.h"
98#include "llvm/ADT/DenseMap.h"
99#include "llvm/ADT/FloatingPointMode.h"
100#include "llvm/ADT/FoldingSet.h"
101#include "llvm/ADT/Hashing.h"
102#include "llvm/ADT/IntrusiveRefCntPtr.h"
103#include "llvm/ADT/STLExtras.h"
104#include "llvm/ADT/ScopeExit.h"
105#include "llvm/ADT/SmallPtrSet.h"
106#include "llvm/ADT/SmallString.h"
107#include "llvm/ADT/SmallVector.h"
108#include "llvm/ADT/StringExtras.h"
109#include "llvm/ADT/StringMap.h"
110#include "llvm/ADT/StringRef.h"
111#include "llvm/ADT/iterator_range.h"
112#include "llvm/Bitstream/BitstreamReader.h"
113#include "llvm/Support/Casting.h"
114#include "llvm/Support/Compiler.h"
115#include "llvm/Support/Compression.h"
116#include "llvm/Support/DJB.h"
117#include "llvm/Support/Endian.h"
118#include "llvm/Support/Error.h"
119#include "llvm/Support/ErrorHandling.h"
120#include "llvm/Support/FileSystem.h"
121#include "llvm/Support/LEB128.h"
122#include "llvm/Support/MemoryBuffer.h"
123#include "llvm/Support/Path.h"
124#include "llvm/Support/SaveAndRestore.h"
125#include "llvm/Support/TimeProfiler.h"
126#include "llvm/Support/Timer.h"
127#include "llvm/Support/VersionTuple.h"
128#include "llvm/Support/raw_ostream.h"
129#include "llvm/TargetParser/Triple.h"
142#include <system_error>
147using namespace clang;
150using llvm::BitstreamCursor;
158 return First->ReadFullVersionInformation(FullVersion) ||
159 Second->ReadFullVersionInformation(FullVersion);
163 First->ReadModuleName(ModuleName);
164 Second->ReadModuleName(ModuleName);
168 First->ReadModuleMapFile(ModuleMapPath);
169 Second->ReadModuleMapFile(ModuleMapPath);
175 bool AllowCompatibleDifferences) {
176 return First->ReadLanguageOptions(LangOpts, Complain,
177 AllowCompatibleDifferences) ||
178 Second->ReadLanguageOptions(LangOpts, Complain,
179 AllowCompatibleDifferences);
184 bool AllowCompatibleDifferences) {
185 return First->ReadTargetOptions(TargetOpts, Complain,
186 AllowCompatibleDifferences) ||
187 Second->ReadTargetOptions(TargetOpts, Complain,
188 AllowCompatibleDifferences);
193 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
194 Second->ReadDiagnosticOptions(DiagOpts, Complain);
200 return First->ReadFileSystemOptions(FSOpts, Complain) ||
201 Second->ReadFileSystemOptions(FSOpts, Complain);
207 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
209 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
215 std::string &SuggestedPredefines) {
216 return First->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
217 SuggestedPredefines) ||
218 Second->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
219 SuggestedPredefines);
224 First->ReadCounter(M,
Value);
225 Second->ReadCounter(M,
Value);
229 return First->needsInputFileVisitation() ||
230 Second->needsInputFileVisitation();
234 return First->needsSystemInputFileVisitation() ||
235 Second->needsSystemInputFileVisitation();
240 First->visitModuleFile(
Filename, Kind);
241 Second->visitModuleFile(
Filename, Kind);
247 bool isExplicitModule) {
248 bool Continue =
false;
249 if (First->needsInputFileVisitation() &&
250 (!isSystem || First->needsSystemInputFileVisitation()))
251 Continue |= First->visitInputFile(
Filename, isSystem, isOverridden,
253 if (Second->needsInputFileVisitation() &&
254 (!isSystem || Second->needsSystemInputFileVisitation()))
255 Continue |= Second->visitInputFile(
Filename, isSystem, isOverridden,
262 First->readModuleFileExtension(Metadata);
263 Second->readModuleFileExtension(Metadata);
283 bool AllowCompatibleDifferences =
true) {
284#define LANGOPT(Name, Bits, Default, Description) \
285 if (ExistingLangOpts.Name != LangOpts.Name) { \
288 Diags->Report(diag::err_pch_langopt_mismatch) \
289 << Description << LangOpts.Name << ExistingLangOpts.Name; \
291 Diags->Report(diag::err_pch_langopt_value_mismatch) \
297#define VALUE_LANGOPT(Name, Bits, Default, Description) \
298 if (ExistingLangOpts.Name != LangOpts.Name) { \
300 Diags->Report(diag::err_pch_langopt_value_mismatch) \
305#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
306 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
308 Diags->Report(diag::err_pch_langopt_value_mismatch) \
313#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
314 if (!AllowCompatibleDifferences) \
315 LANGOPT(Name, Bits, Default, Description)
317#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
318 if (!AllowCompatibleDifferences) \
319 ENUM_LANGOPT(Name, Bits, Default, Description)
321#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
322 if (!AllowCompatibleDifferences) \
323 VALUE_LANGOPT(Name, Bits, Default, Description)
325#define BENIGN_LANGOPT(Name, Bits, Default, Description)
326#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
327#define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description)
328#include "clang/Basic/LangOptions.def"
332 Diags->
Report(diag::err_pch_langopt_value_mismatch) <<
"module features";
338 Diags->
Report(diag::err_pch_langopt_value_mismatch)
339 <<
"target Objective-C runtime";
346 Diags->
Report(diag::err_pch_langopt_value_mismatch)
347 <<
"block command names";
355 if (!AllowCompatibleDifferences) {
359 ExistingSanitizers.
clear(ModularSanitizers);
360 ImportedSanitizers.
clear(ModularSanitizers);
361 if (ExistingSanitizers.
Mask != ImportedSanitizers.
Mask) {
362 const std::string Flag =
"-fsanitize=";
364#define SANITIZER(NAME, ID) \
366 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
367 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
368 if (InExistingModule != InImportedModule) \
369 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
370 << InExistingModule << (Flag + NAME); \
372#include "clang/Basic/Sanitizers.def"
390 bool AllowCompatibleDifferences =
true) {
391#define CHECK_TARGET_OPT(Field, Name) \
392 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
394 Diags->Report(diag::err_pch_targetopt_mismatch) \
395 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
406 if (!AllowCompatibleDifferences) {
411#undef CHECK_TARGET_OPT
419 llvm::sort(ExistingFeatures);
420 llvm::sort(ReadFeatures);
426 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
427 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
428 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
429 ExistingFeatures.begin(), ExistingFeatures.end(),
430 std::back_inserter(UnmatchedReadFeatures));
434 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
438 for (StringRef Feature : UnmatchedReadFeatures)
439 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
441 for (StringRef Feature : UnmatchedExistingFeatures)
442 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
446 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
452 bool AllowCompatibleDifferences) {
455 Complain ? &Reader.Diags :
nullptr,
456 AllowCompatibleDifferences);
461 bool AllowCompatibleDifferences) {
464 Complain ? &Reader.Diags :
nullptr,
465 AllowCompatibleDifferences);
470using MacroDefinitionsMap =
471 llvm::StringMap<std::pair<StringRef,
bool >>;
472using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
487 for (
auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
496 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror=" +
515 bool SystemHeaderWarningsInModule,
524 !SystemHeaderWarningsInModule) {
526 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Wsystem-headers";
533 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror";
540 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Weverything -Werror";
547 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-pedantic-errors";
571 assert(!ModuleName.empty() &&
"diagnostic options read before module name");
575 assert(M &&
"missing module");
590 assert(ModuleMgr.
size() >= 1 &&
"what ASTFile is this then");
599 bool SystemHeaderWarningsInModule =
606 SystemHeaderWarningsInModule, Complain);
613 MacroDefinitionsMap &Macros,
615 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
616 StringRef Macro = PPOpts.
Macros[I].first;
617 bool IsUndef = PPOpts.
Macros[I].second;
619 std::pair<StringRef, StringRef> MacroPair = Macro.split(
'=');
620 StringRef MacroName = MacroPair.first;
621 StringRef MacroBody = MacroPair.second;
625 if (MacroNames && !Macros.count(MacroName))
626 MacroNames->push_back(MacroName);
628 Macros[MacroName] = std::make_pair(
"",
true);
633 if (MacroName.size() == Macro.size())
637 StringRef::size_type End = MacroBody.find_first_of(
"\n\r");
638 MacroBody = MacroBody.substr(0, End);
641 if (MacroNames && !Macros.count(MacroName))
642 MacroNames->push_back(MacroName);
643 Macros[MacroName] = std::make_pair(MacroBody,
false);
667 std::string &SuggestedPredefines,
const LangOptions &LangOpts,
671 MacroDefinitionsMap ASTFileMacros;
673 MacroDefinitionsMap ExistingMacros;
676 &ExistingMacroNames);
680 SuggestedPredefines +=
"# 1 \"<command line>\" 1\n";
682 for (
unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
684 StringRef MacroName = ExistingMacroNames[I];
685 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
688 llvm::StringMap<std::pair<StringRef,
bool >>::iterator Known =
689 ASTFileMacros.find(MacroName);
695 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
true;
703 if (Existing.second) {
704 SuggestedPredefines +=
"#undef ";
705 SuggestedPredefines += MacroName.str();
706 SuggestedPredefines +=
'\n';
708 SuggestedPredefines +=
"#define ";
709 SuggestedPredefines += MacroName.str();
710 SuggestedPredefines +=
' ';
711 SuggestedPredefines += Existing.first.str();
712 SuggestedPredefines +=
'\n';
719 if (Existing.second != Known->second.second) {
721 Diags->
Report(diag::err_pch_macro_def_undef)
722 << MacroName << Known->second.second;
729 if (Existing.second || Existing.first == Known->second.first) {
730 ASTFileMacros.erase(Known);
736 Diags->
Report(diag::err_pch_macro_def_conflict)
737 << MacroName << Known->second.first << Existing.first;
743 SuggestedPredefines +=
"# 1 \"<built-in>\" 2\n";
748 for (
const auto &MacroName : ASTFileMacros.keys()) {
750 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
false;
767 if (LangOpts.Modules &&
777 for (
unsigned I = 0, N = ExistingPPOpts.
Includes.size(); I != N; ++I) {
784 SuggestedPredefines +=
"#include \"";
785 SuggestedPredefines +=
File;
786 SuggestedPredefines +=
"\"\n";
796 SuggestedPredefines +=
"#include \"";
797 SuggestedPredefines +=
File;
798 SuggestedPredefines +=
"\"\n";
801 for (
unsigned I = 0, N = ExistingPPOpts.
MacroIncludes.size(); I != N; ++I) {
806 SuggestedPredefines +=
"#__include_macros \"";
807 SuggestedPredefines +=
File;
808 SuggestedPredefines +=
"\"\n##\n";
815 bool ReadMacros,
bool Complain,
816 std::string &SuggestedPredefines) {
820 PPOpts, ExistingPPOpts, ReadMacros, Complain ? &Reader.Diags :
nullptr,
826 std::string &SuggestedPredefines) {
838 StringRef SpecificModuleCachePath,
839 StringRef ExistingModuleCachePath,
844 SpecificModuleCachePath == ExistingModuleCachePath)
847 VFS.equivalent(SpecificModuleCachePath, ExistingModuleCachePath);
848 if (EqualOrErr && *EqualOrErr)
851 Diags->
Report(diag::err_pch_modulecache_mismatch)
852 << SpecificModuleCachePath << ExistingModuleCachePath;
857 StringRef SpecificModuleCachePath,
860 SpecificModuleCachePath,
862 Complain ? &Reader.Diags :
nullptr,
876 const char *Error =
nullptr;
878 uint64_t Val = llvm::decodeULEB128(
P, &Length,
nullptr, &Error);
880 llvm::report_fatal_error(Error);
886static std::pair<unsigned, unsigned>
889 if ((
unsigned)KeyLen != KeyLen)
890 llvm::report_fatal_error(
"key too large");
893 if ((
unsigned)DataLen != DataLen)
894 llvm::report_fatal_error(
"data too large");
896 return std::make_pair(KeyLen, DataLen);
900 bool TakeOwnership) {
901 DeserializationListener = Listener;
902 OwnsDeserializationListener = TakeOwnership;
909std::pair<unsigned, unsigned>
916 using namespace llvm::support;
919 unsigned N = endian::readNext<uint16_t, llvm::endianness::little>(d);
921 F, endian::readNext<uint32_t, llvm::endianness::little>(d));
928 Args.push_back(FirstII);
929 for (
unsigned I = 1; I != N; ++I)
930 Args.push_back(Reader.getLocalIdentifier(
931 F, endian::readNext<uint32_t, llvm::endianness::little>(d)));
939 using namespace llvm::support;
943 Result.ID = Reader.getGlobalSelectorID(
944 F, endian::readNext<uint32_t, llvm::endianness::little>(d));
945 unsigned FullInstanceBits =
946 endian::readNext<uint16_t, llvm::endianness::little>(d);
947 unsigned FullFactoryBits =
948 endian::readNext<uint16_t, llvm::endianness::little>(d);
949 Result.InstanceBits = FullInstanceBits & 0x3;
950 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
951 Result.FactoryBits = FullFactoryBits & 0x3;
952 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
953 unsigned NumInstanceMethods = FullInstanceBits >> 3;
954 unsigned NumFactoryMethods = FullFactoryBits >> 3;
957 for (
unsigned I = 0; I != NumInstanceMethods; ++I) {
960 LocalDeclID(endian::readNext<DeclID, llvm::endianness::little>(d))))
961 Result.Instance.push_back(Method);
965 for (
unsigned I = 0; I != NumFactoryMethods; ++I) {
968 LocalDeclID(endian::readNext<DeclID, llvm::endianness::little>(d))))
969 Result.Factory.push_back(Method);
976 return llvm::djbHash(a);
979std::pair<unsigned, unsigned>
986 assert(n >= 2 && d[n-1] ==
'\0');
987 return StringRef((
const char*) d, n-1);
1004 bool Value = Bits & 0x1;
1010 using namespace llvm::support;
1012 unsigned RawID = endian::readNext<uint32_t, llvm::endianness::little>(d);
1013 return Reader.getGlobalIdentifierID(F, RawID >> 1);
1026 const unsigned char* d,
1028 using namespace llvm::support;
1030 unsigned RawID = endian::readNext<uint32_t, llvm::endianness::little>(d);
1031 bool IsInteresting = RawID & 0x01;
1039 II = &Reader.getIdentifierTable().getOwn(k);
1043 Reader.markIdentifierUpToDate(II);
1045 IdentifierID ID = Reader.getGlobalIdentifierID(F, RawID);
1046 if (!IsInteresting) {
1049 Reader.SetIdentifierInfo(ID, II);
1053 unsigned ObjCOrBuiltinID =
1054 endian::readNext<uint16_t, llvm::endianness::little>(d);
1055 unsigned Bits = endian::readNext<uint16_t, llvm::endianness::little>(d);
1056 bool CPlusPlusOperatorKeyword =
readBit(Bits);
1057 bool HasRevertedTokenIDToIdentifier =
readBit(Bits);
1058 bool Poisoned =
readBit(Bits);
1059 bool ExtensionToken =
readBit(Bits);
1060 bool HadMacroDefinition =
readBit(Bits);
1062 assert(Bits == 0 &&
"Extra bits in the identifier?");
1067 if (HasRevertedTokenIDToIdentifier && II->
getTokenID() != tok::identifier)
1072 "Incorrect extension token flag");
1073 (void)ExtensionToken;
1077 "Incorrect C++ operator keyword flag");
1078 (void)CPlusPlusOperatorKeyword;
1082 if (HadMacroDefinition) {
1083 uint32_t MacroDirectivesOffset =
1084 endian::readNext<uint32_t, llvm::endianness::little>(d);
1087 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1090 Reader.SetIdentifierInfo(ID, II);
1096 for (; DataLen > 0; DataLen -=
sizeof(
DeclID))
1097 DeclIDs.push_back(Reader.getGlobalDeclID(
1099 LocalDeclID(endian::readNext<DeclID, llvm::endianness::little>(d))));
1100 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1107 : Kind(Name.getNameKind()) {
1110 Data = (uint64_t)Name.getAsIdentifierInfo();
1115 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1118 Data = Name.getCXXOverloadedOperator();
1121 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1124 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1125 ->getDeclName().getAsIdentifierInfo();
1137 llvm::FoldingSetNodeID ID;
1138 ID.AddInteger(Kind);
1161 return ID.ComputeHash();
1165ASTDeclContextNameLookupTrait::ReadFileRef(
const unsigned char *&d) {
1166 using namespace llvm::support;
1168 uint32_t ModuleFileID =
1169 endian::readNext<uint32_t, llvm::endianness::little>(d);
1170 return Reader.getLocalModuleFile(F, ModuleFileID);
1173std::pair<unsigned, unsigned>
1174ASTDeclContextNameLookupTrait::ReadKeyDataLength(
const unsigned char *&d) {
1179ASTDeclContextNameLookupTrait::ReadKey(
const unsigned char *d,
unsigned) {
1180 using namespace llvm::support;
1188 Data = (uint64_t)Reader.getLocalIdentifier(
1189 F, endian::readNext<uint32_t, llvm::endianness::little>(d));
1194 Data = (uint64_t)Reader
1196 F, endian::readNext<uint32_t, llvm::endianness::little>(d))
1214 const unsigned char *d,
1217 using namespace llvm::support;
1219 for (
unsigned NumDecls = DataLen /
sizeof(
DeclID); NumDecls; --NumDecls) {
1220 LocalDeclID LocalID(endian::readNext<DeclID, llvm::endianness::little>(d));
1221 Val.
insert(Reader.getGlobalDeclID(F, LocalID));
1225bool ASTReader::ReadLexicalDeclContextStorage(
ModuleFile &M,
1226 BitstreamCursor &Cursor,
1229 assert(Offset != 0);
1232 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1233 Error(std::move(Err));
1241 Error(MaybeCode.takeError());
1244 unsigned Code = MaybeCode.get();
1247 if (!MaybeRecCode) {
1248 Error(MaybeRecCode.takeError());
1251 unsigned RecCode = MaybeRecCode.get();
1253 Error(
"Expected lexical block");
1257 assert(!isa<TranslationUnitDecl>(DC) &&
1258 "expected a TU_UPDATE_LEXICAL record for TU");
1263 auto &Lex = LexicalDecls[DC];
1265 Lex = std::make_pair(
1267 reinterpret_cast<const unalighed_decl_id_t *
>(Blob.data()),
1268 Blob.size() /
sizeof(
DeclID)));
1274bool ASTReader::ReadVisibleDeclContextStorage(
ModuleFile &M,
1275 BitstreamCursor &Cursor,
1278 assert(Offset != 0);
1281 if (llvm::Error Err =
Cursor.JumpToBit(Offset)) {
1282 Error(std::move(Err));
1290 Error(MaybeCode.takeError());
1293 unsigned Code = MaybeCode.get();
1296 if (!MaybeRecCode) {
1297 Error(MaybeRecCode.takeError());
1300 unsigned RecCode = MaybeRecCode.get();
1302 Error(
"Expected visible lookup table block");
1308 auto *
Data = (
const unsigned char*)Blob.data();
1309 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&M,
Data});
1313void ASTReader::Error(StringRef Msg)
const {
1314 Error(diag::err_fe_pch_malformed, Msg);
1315 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1316 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1317 Diag(diag::note_module_cache_path)
1318 << PP.getHeaderSearchInfo().getModuleCachePath();
1322void ASTReader::Error(
unsigned DiagID, StringRef Arg1, StringRef Arg2,
1323 StringRef Arg3)
const {
1324 if (Diags.isDiagnosticInFlight())
1325 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1327 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1330void ASTReader::Error(llvm::Error &&Err)
const {
1331 llvm::Error RemainingErr =
1338 assert(NumArgs <= 3 &&
"Can only have up to 3 arguments");
1339 StringRef Arg1, Arg2, Arg3;
1342 Arg3 =
Diag.getStringArg(2);
1345 Arg2 =
Diag.getStringArg(1);
1348 Arg1 =
Diag.getStringArg(0);
1350 Error(
Diag.getDiagID(), Arg1, Arg2, Arg3);
1366 std::map<int, int> FileIDs;
1368 for (
unsigned I = 0;
Record[Idx]; ++I) {
1376 std::vector<LineEntry> Entries;
1377 while (Idx <
Record.size()) {
1381 unsigned NumEntries =
Record[Idx++];
1382 assert(NumEntries &&
"no line entries for file ID");
1384 Entries.reserve(NumEntries);
1385 for (
unsigned I = 0; I != NumEntries; ++I) {
1386 unsigned FileOffset =
Record[Idx++];
1387 unsigned LineNo =
Record[Idx++];
1388 int FilenameID = FileIDs[
Record[Idx++]];
1391 unsigned IncludeOffset =
Record[Idx++];
1393 FileKind, IncludeOffset));
1400llvm::Error ASTReader::ReadSourceManagerBlock(
ModuleFile &F) {
1401 using namespace SrcMgr;
1409 SLocEntryCursor = F.
Stream;
1412 if (llvm::Error Err = F.
Stream.SkipBlock())
1423 SLocEntryCursor.advanceSkippingSubblocks();
1425 return MaybeE.takeError();
1426 llvm::BitstreamEntry E = MaybeE.get();
1429 case llvm::BitstreamEntry::SubBlock:
1430 case llvm::BitstreamEntry::Error:
1431 return llvm::createStringError(std::errc::illegal_byte_sequence,
1432 "malformed block record in AST file");
1433 case llvm::BitstreamEntry::EndBlock:
1434 return llvm::Error::success();
1435 case llvm::BitstreamEntry::Record:
1444 SLocEntryCursor.readRecord(E.ID,
Record, &Blob);
1446 return MaybeRecord.takeError();
1447 switch (MaybeRecord.get()) {
1455 return llvm::Error::success();
1466 return std::move(Err);
1470 return MaybeEntry.takeError();
1472 llvm::BitstreamEntry Entry = MaybeEntry.get();
1473 if (Entry.Kind != llvm::BitstreamEntry::Record)
1474 return llvm::createStringError(
1475 std::errc::illegal_byte_sequence,
1476 "incorrectly-formatted source location entry in AST file");
1482 return MaybeSLOC.takeError();
1484 switch (MaybeSLOC.get()) {
1486 return llvm::createStringError(
1487 std::errc::illegal_byte_sequence,
1488 "incorrectly-formatted source location entry in AST file");
1498 GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - SLocOffset - 1);
1499 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
1500 "Corrupted global sloc offset map");
1505 auto It = llvm::upper_bound(
1508 int ID = F->SLocEntryBaseID + LocalIndex;
1509 std::size_t Index = -ID - 2;
1510 if (!SourceMgr.SLocEntryOffsetLoaded[Index]) {
1511 assert(!SourceMgr.SLocEntryLoaded[Index]);
1512 auto MaybeEntryOffset = readSLocOffset(F, LocalIndex);
1513 if (!MaybeEntryOffset) {
1514 Error(MaybeEntryOffset.takeError());
1518 SourceMgr.LoadedSLocEntryTable[Index] =
1519 SrcMgr::SLocEntry::getOffsetOnly(*MaybeEntryOffset);
1520 SourceMgr.SLocEntryOffsetLoaded[Index] = true;
1522 return Offset < SourceMgr.LoadedSLocEntryTable[Index].getOffset();
1537 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1538 Error(
"source location entry ID out-of-range for AST file");
1544 auto ReadBuffer = [
this](
1545 BitstreamCursor &SLocEntryCursor,
1546 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1551 Error(MaybeCode.takeError());
1554 unsigned Code = MaybeCode.get();
1557 SLocEntryCursor.readRecord(Code,
Record, &Blob);
1558 if (!MaybeRecCode) {
1559 Error(MaybeRecCode.takeError());
1562 unsigned RecCode = MaybeRecCode.get();
1567 const llvm::compression::Format F =
1568 Blob.size() > 0 && Blob.data()[0] == 0x78
1569 ? llvm::compression::Format::Zlib
1570 : llvm::compression::Format::Zstd;
1571 if (
const char *Reason = llvm::compression::getReasonIfUnsupported(F)) {
1576 if (llvm::Error E = llvm::compression::decompress(
1577 F, llvm::arrayRefFromStringRef(Blob), Decompressed,
Record[0])) {
1578 Error(
"could not decompress embedded file contents: " +
1579 llvm::toString(std::move(E)));
1582 return llvm::MemoryBuffer::getMemBufferCopy(
1583 llvm::toStringRef(Decompressed), Name);
1585 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name,
true);
1587 Error(
"AST record has invalid code");
1592 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1596 Error(std::move(Err));
1603 ++NumSLocEntriesRead;
1606 Error(MaybeEntry.takeError());
1609 llvm::BitstreamEntry Entry = MaybeEntry.get();
1611 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1612 Error(
"incorrectly-formatted source location entry in AST file");
1619 SLocEntryCursor.readRecord(Entry.ID,
Record, &Blob);
1621 Error(MaybeSLOC.takeError());
1624 switch (MaybeSLOC.get()) {
1626 Error(
"incorrectly-formatted source location entry in AST file");
1632 unsigned InputID =
Record[4];
1633 InputFile IF = getInputFile(*F, InputID);
1646 IncludeLoc = getImportLocation(F);
1650 FileID FID = SourceMgr.createFileID(*
File, IncludeLoc, FileCharacter, ID,
1654 FileInfo.NumCreatedFIDs =
Record[5];
1658 unsigned NumFileDecls =
Record[7];
1659 if (NumFileDecls && ContextObj) {
1661 assert(F->
FileSortedDecls &&
"FILE_SORTED_DECLS not encountered yet ?");
1667 SourceMgr.getOrCreateContentCache(*
File, isSystem(FileCharacter));
1671 auto Buffer = ReadBuffer(SLocEntryCursor,
File->getName());
1674 SourceMgr.overrideFileContents(*
File, std::move(Buffer));
1681 const char *Name = Blob.data();
1682 unsigned Offset =
Record[0];
1687 IncludeLoc = getImportLocation(F);
1690 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1693 FileID FID = SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1694 BaseOffset + Offset, IncludeLoc);
1708 SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
1722 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1723 Error(
"source location entry ID out-of-range for AST file");
1728 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1746 assert(SourceMgr.getMainFileID().isValid() &&
"missing main file");
1747 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1757 uint64_t *StartOfBlockOffset) {
1758 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID))
1761 if (StartOfBlockOffset)
1762 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1765 uint64_t Offset = Cursor.GetCurrentBitNo();
1768 return MaybeCode.takeError();
1769 unsigned Code = MaybeCode.get();
1772 if (Code != llvm::bitc::DEFINE_ABBREV) {
1773 if (llvm::Error Err = Cursor.JumpToBit(Offset))
1775 return llvm::Error::success();
1777 if (llvm::Error Err = Cursor.ReadAbbrevRecord())
1793 case tok::annot_pragma_loop_hint: {
1796 Info->Option = ReadToken(M,
Record, Idx);
1797 unsigned NumTokens =
Record[Idx++];
1799 Toks.reserve(NumTokens);
1800 for (
unsigned I = 0; I < NumTokens; ++I)
1801 Toks.push_back(ReadToken(M,
Record, Idx));
1802 Info->Toks =
llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
1806 case tok::annot_pragma_pack: {
1809 auto SlotLabel = ReadString(
Record, Idx);
1811 llvm::StringRef(SlotLabel).copy(PP.getPreprocessorAllocator());
1812 Info->Alignment = ReadToken(M,
Record, Idx);
1817 case tok::annot_pragma_openmp:
1818 case tok::annot_pragma_openmp_end:
1819 case tok::annot_pragma_unused:
1820 case tok::annot_pragma_openacc:
1821 case tok::annot_pragma_openacc_end:
1824 llvm_unreachable(
"missing deserialization code for annotation token");
1841 if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1843 consumeError(std::move(Err));
1855 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1857 Stream.advanceSkippingSubblocks(Flags);
1859 Error(MaybeEntry.takeError());
1862 llvm::BitstreamEntry Entry = MaybeEntry.get();
1864 switch (Entry.Kind) {
1865 case llvm::BitstreamEntry::SubBlock:
1866 case llvm::BitstreamEntry::Error:
1867 Error(
"malformed block record in AST file");
1869 case llvm::BitstreamEntry::EndBlock:
1871 case llvm::BitstreamEntry::Record:
1882 Error(MaybeRecType.takeError());
1898 unsigned NextIndex = 1;
1905 PP.getPreprocessorAllocator());
1908 bool isC99VarArgs =
Record[NextIndex++];
1909 bool isGNUVarArgs =
Record[NextIndex++];
1910 bool hasCommaPasting =
Record[NextIndex++];
1911 MacroParams.clear();
1912 unsigned NumArgs =
Record[NextIndex++];
1913 for (
unsigned i = 0; i != NumArgs; ++i)
1914 MacroParams.push_back(getLocalIdentifier(F,
Record[NextIndex++]));
1928 if (NextIndex + 1 ==
Record.size() && PP.getPreprocessingRecord() &&
1932 GlobalID = getGlobalPreprocessedEntityID(F,
Record[NextIndex]);
1934 PreprocessingRecord::PPEntityID PPID =
1935 PPRec.getPPEntityID(GlobalID - 1,
true);
1937 PPRec.getPreprocessedEntity(PPID));
1939 PPRec.RegisterMacroDefinition(Macro, PPDef);
1950 if (MacroTokens.empty()) {
1951 Error(
"unexpected number of macro tokens for a macro in AST file");
1956 MacroTokens[0] = ReadToken(F,
Record, Idx);
1957 MacroTokens = MacroTokens.drop_front();
1966 unsigned LocalID)
const {
1968 ReadModuleOffsetMap(M);
1973 &&
"Invalid index into preprocessed entity index remap");
1975 return LocalID + I->second;
1978const FileEntry *HeaderFileInfoTrait::getFile(
const internal_key_type &Key) {
1980 if (!Key.Imported) {
1986 std::string Resolved = std::string(Key.Filename);
1987 Reader.ResolveImportedPath(M, Resolved);
1994 return llvm::hash_combine(ikey.
Size, ikey.
ModTime);
2015 return FEA && FEA == FEB;
2018std::pair<unsigned, unsigned>
2019HeaderFileInfoTrait::ReadKeyDataLength(
const unsigned char*& d) {
2024HeaderFileInfoTrait::ReadKey(
const unsigned char *d,
unsigned) {
2025 using namespace llvm::support;
2028 ikey.
Size = off_t(endian::readNext<uint64_t, llvm::endianness::little>(d));
2030 time_t(endian::readNext<uint64_t, llvm::endianness::little>(d));
2039 using namespace llvm::support;
2041 const unsigned char *End = d + DataLen;
2043 unsigned Flags = *d++;
2045 bool Included = (Flags >> 6) & 0x01;
2050 Reader.getPreprocessor().getIncludedFiles().insert(FE);
2053 HFI.
isImport |= (Flags >> 5) & 0x01;
2055 HFI.
DirInfo = (Flags >> 1) & 0x07;
2058 M, endian::readNext<uint32_t, llvm::endianness::little>(d));
2059 if (
unsigned FrameworkOffset =
2060 endian::readNext<uint32_t, llvm::endianness::little>(d)) {
2063 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
2064 HFI.
Framework = HS->getUniqueFrameworkName(FrameworkName);
2067 assert((End - d) % 4 == 0 &&
2068 "Wrong data length in HeaderFileInfo deserialization");
2070 uint32_t LocalSMID =
2071 endian::readNext<uint32_t, llvm::endianness::little>(d);
2077 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
2078 Module *Mod = Reader.getSubmodule(GlobalSMID);
2081 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
2085 Reader.ResolveImportedPath(M,
Filename);
2089 ModMap.
addHeader(Mod, H, HeaderRole,
true);
2101 uint32_t MacroDirectivesOffset) {
2102 assert(NumCurrentElementsDeserializing > 0 &&
"Missing deserialization guard");
2103 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
2110 for (
ModuleFile &I : llvm::reverse(ModuleMgr)) {
2111 BitstreamCursor &MacroCursor = I.MacroCursor;
2114 if (MacroCursor.getBitcodeBytes().empty())
2117 BitstreamCursor Cursor = MacroCursor;
2118 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
2119 Error(std::move(Err));
2127 Error(MaybeE.takeError());
2130 llvm::BitstreamEntry E = MaybeE.get();
2133 case llvm::BitstreamEntry::SubBlock:
2134 case llvm::BitstreamEntry::Error:
2135 Error(
"malformed block record in AST file");
2137 case llvm::BitstreamEntry::EndBlock:
2140 case llvm::BitstreamEntry::Record: {
2144 Error(MaybeRecord.takeError());
2147 switch (MaybeRecord.get()) {
2155 updateOutOfDateIdentifier(*II);
2174 class IdentifierLookupVisitor {
2177 unsigned PriorGeneration;
2178 unsigned &NumIdentifierLookups;
2179 unsigned &NumIdentifierLookupHits;
2183 IdentifierLookupVisitor(StringRef Name,
unsigned PriorGeneration,
2184 unsigned &NumIdentifierLookups,
2185 unsigned &NumIdentifierLookupHits)
2187 PriorGeneration(PriorGeneration),
2188 NumIdentifierLookups(NumIdentifierLookups),
2189 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2203 ++NumIdentifierLookups;
2204 ASTIdentifierLookupTable::iterator Pos =
2205 IdTable->find_hashed(Name, NameHash, &Trait);
2206 if (Pos == IdTable->end())
2212 ++NumIdentifierLookupHits;
2228 unsigned PriorGeneration = 0;
2229 if (getContext().getLangOpts().Modules)
2230 PriorGeneration = IdentifierGeneration[&II];
2236 if (!loadGlobalIndex()) {
2237 if (GlobalIndex->lookupIdentifier(II.
getName(), Hits)) {
2242 IdentifierLookupVisitor Visitor(II.
getName(), PriorGeneration,
2243 NumIdentifierLookups,
2244 NumIdentifierLookupHits);
2245 ModuleMgr.visit(Visitor, HitsPtr);
2246 markIdentifierUpToDate(&II);
2256 if (getContext().getLangOpts().Modules)
2257 IdentifierGeneration[II] = getGeneration();
2261 const PendingMacroInfo &PMInfo) {
2266 if (llvm::Error Err =
2268 Error(std::move(Err));
2272 struct ModuleMacroRecord {
2285 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2287 Error(MaybeEntry.takeError());
2290 llvm::BitstreamEntry Entry = MaybeEntry.get();
2292 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2293 Error(
"malformed block record in AST file");
2300 Error(MaybePP.takeError());
2308 ModuleMacros.push_back(ModuleMacroRecord());
2309 auto &Info = ModuleMacros.back();
2310 Info.SubModID = getGlobalSubmoduleID(M,
Record[0]);
2311 Info.MI = getMacro(getGlobalMacroID(M,
Record[1]));
2312 for (
int I = 2, N =
Record.size(); I != N; ++I)
2313 Info.Overrides.push_back(getGlobalSubmoduleID(M,
Record[I]));
2318 Error(
"malformed block record in AST file");
2329 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2331 for (
auto &MMR : ModuleMacros) {
2333 for (
unsigned ModID : MMR.Overrides) {
2334 Module *Mod = getSubmodule(ModID);
2335 auto *Macro = PP.getModuleMacro(Mod, II);
2336 assert(Macro &&
"missing definition for overridden macro");
2337 Overrides.push_back(Macro);
2340 bool Inserted =
false;
2341 Module *Owner = getSubmodule(MMR.SubModID);
2342 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2353 unsigned Idx = 0, N =
Record.size();
2361 MD = PP.AllocateDefMacroDirective(MI,
Loc);
2365 MD = PP.AllocateUndefMacroDirective(
Loc);
2368 bool isPublic =
Record[Idx++];
2369 MD = PP.AllocateVisibilityMacroDirective(
Loc, isPublic);
2381 PP.setLoadedMacroDirective(II, Earliest, Latest);
2384bool ASTReader::shouldDisableValidationForFile(
2422 consumeError(std::move(Err));
2428 consumeError(MaybeCode.takeError());
2430 unsigned Code = MaybeCode.get();
2436 "invalid record type for input file");
2439 consumeError(Maybe.takeError());
2442 assert(
Record[0] == ID &&
"Bogus stored ID or offset");
2451 uint16_t AsRequestedLength =
Record[7];
2453 std::string NameAsRequested = Blob.substr(0, AsRequestedLength).str();
2454 std::string Name = Blob.substr(AsRequestedLength).str();
2456 ResolveImportedPath(F, NameAsRequested);
2457 ResolveImportedPath(F, Name);
2460 Name = NameAsRequested;
2462 return std::make_pair(std::move(NameAsRequested), std::move(Name));
2467 consumeError(MaybeEntry.takeError());
2468 llvm::BitstreamEntry Entry = MaybeEntry.get();
2469 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2470 "expected record type for input file hash");
2475 "invalid record type for input file hash");
2478 consumeError(Maybe.takeError());
2507 consumeError(std::move(Err));
2522 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2535 if ((Overridden || Transient || SkipChecks) && !
File)
2540 std::string ErrorStr =
"could not find file '";
2542 ErrorStr +=
"' referenced by AST file '";
2558 if ((!Overridden && !Transient) && !SkipChecks &&
2559 SM.isFileOverridden(*
File)) {
2573 enum ModificationKind {
2579 std::optional<int64_t> Old = std::nullopt;
2580 std::optional<int64_t> New = std::nullopt;
2582 auto HasInputContentChanged = [&](Change OriginalChange) {
2583 assert(ValidateASTInputFilesContent &&
2584 "We should only check the content of the inputs with "
2585 "ValidateASTInputFilesContent enabled.");
2587 if (StoredContentHash ==
static_cast<uint64_t>(llvm::hash_code(-1)))
2588 return OriginalChange;
2591 if (!MemBuffOrError) {
2593 return OriginalChange;
2594 std::string ErrorStr =
"could not get buffer for file '";
2595 ErrorStr +=
File->getName();
2598 return OriginalChange;
2602 auto ContentHash =
hash_value(MemBuffOrError.get()->getBuffer());
2603 if (StoredContentHash ==
static_cast<uint64_t>(ContentHash))
2604 return Change{Change::None};
2606 return Change{Change::Content};
2608 auto HasInputFileChanged = [&]() {
2609 if (StoredSize !=
File->getSize())
2610 return Change{Change::Size, StoredSize,
File->getSize()};
2611 if (!shouldDisableValidationForFile(F) && StoredTime &&
2612 StoredTime !=
File->getModificationTime()) {
2613 Change MTimeChange = {Change::ModTime, StoredTime,
2614 File->getModificationTime()};
2618 if (ValidateASTInputFilesContent)
2619 return HasInputContentChanged(MTimeChange);
2623 return Change{Change::None};
2626 bool IsOutOfDate =
false;
2627 auto FileChange = SkipChecks ? Change{Change::None} : HasInputFileChanged();
2633 FileChange = HasInputContentChanged(FileChange);
2639 if (!StoredTime && ValidateASTInputFilesContent &&
2640 FileChange.Kind == Change::None)
2641 FileChange = HasInputContentChanged(FileChange);
2644 if (!Overridden && FileChange.Kind != Change::None) {
2645 if (Complain && !Diags.isDiagnosticInFlight()) {
2648 while (!ImportStack.back()->ImportedBy.empty())
2649 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2652 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2653 Diag(diag::err_fe_ast_file_modified)
2655 << TopLevelPCHName << FileChange.Kind
2656 << (FileChange.Old && FileChange.New)
2657 << llvm::itostr(FileChange.Old.value_or(0))
2658 << llvm::itostr(FileChange.New.value_or(0));
2661 if (ImportStack.size() > 1) {
2662 Diag(diag::note_pch_required_by)
2663 <<
Filename << ImportStack[0]->FileName;
2664 for (
unsigned I = 1; I < ImportStack.size(); ++I)
2665 Diag(diag::note_pch_required_by)
2666 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2669 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2699 llvm::sys::path::append(Buffer, Prefix,
Filename);
2700 Filename.assign(Buffer.begin(), Buffer.end());
2715 llvm_unreachable(
"unknown ASTReadResult");
2719 BitstreamCursor &Stream,
unsigned ClientLoadCapabilities,
2721 std::string &SuggestedPredefines) {
2724 consumeError(std::move(Err));
2735 consumeError(MaybeEntry.takeError());
2738 llvm::BitstreamEntry Entry = MaybeEntry.get();
2740 switch (Entry.Kind) {
2741 case llvm::BitstreamEntry::Error:
2742 case llvm::BitstreamEntry::SubBlock:
2745 case llvm::BitstreamEntry::EndBlock:
2748 case llvm::BitstreamEntry::Record:
2756 if (!MaybeRecordType) {
2758 consumeError(MaybeRecordType.takeError());
2763 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2764 if (ParseLanguageOptions(
Record, Complain, Listener,
2765 AllowCompatibleConfigurationMismatch))
2766 Result = ConfigurationMismatch;
2771 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2772 if (ParseTargetOptions(
Record, Complain, Listener,
2773 AllowCompatibleConfigurationMismatch))
2774 Result = ConfigurationMismatch;
2779 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2780 if (!AllowCompatibleConfigurationMismatch &&
2781 ParseFileSystemOptions(
Record, Complain, Listener))
2782 Result = ConfigurationMismatch;
2787 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2788 if (!AllowCompatibleConfigurationMismatch &&
2789 ParseHeaderSearchOptions(
Record, Complain, Listener))
2790 Result = ConfigurationMismatch;
2795 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2796 if (!AllowCompatibleConfigurationMismatch &&
2797 ParsePreprocessorOptions(
Record, Complain, Listener,
2798 SuggestedPredefines))
2799 Result = ConfigurationMismatch;
2809 unsigned ClientLoadCapabilities) {
2810 BitstreamCursor &Stream = F.
Stream;
2813 Error(std::move(Err));
2823 bool HasReadUnhashedControlBlock =
false;
2824 auto readUnhashedControlBlockOnce = [&]() {
2825 if (!HasReadUnhashedControlBlock) {
2826 HasReadUnhashedControlBlock =
true;
2827 if (ASTReadResult
Result =
2828 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2834 bool DisableValidation = shouldDisableValidationForFile(F);
2838 unsigned NumInputs = 0;
2839 unsigned NumUserInputs = 0;
2840 StringRef BaseDirectoryAsWritten;
2844 Error(MaybeEntry.takeError());
2847 llvm::BitstreamEntry Entry = MaybeEntry.get();
2849 switch (Entry.Kind) {
2850 case llvm::BitstreamEntry::Error:
2851 Error(
"malformed block record in AST file");
2853 case llvm::BitstreamEntry::EndBlock: {
2856 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2861 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2868 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2874 unsigned N = ValidateSystemInputs ? NumInputs : NumUserInputs;
2880 for (
unsigned I = 0; I < N; ++I) {
2881 InputFile IF = getInputFile(F, I+1, Complain);
2893 for (
unsigned I = 0; I < N; ++I) {
2894 bool IsSystem = I >= NumUserInputs;
2905 case llvm::BitstreamEntry::SubBlock:
2909 if (llvm::Error Err = Stream.SkipBlock()) {
2910 Error(std::move(Err));
2914 Error(
"malformed block record in AST file");
2924 if (Listener && !ImportedBy) {
2930 bool AllowCompatibleConfigurationMismatch =
2934 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2935 AllowCompatibleConfigurationMismatch, *Listener,
2936 SuggestedPredefines);
2938 Error(
"malformed block record in AST file");
2942 if (DisableValidation ||
2943 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
2951 }
else if (llvm::Error Err = Stream.SkipBlock()) {
2952 Error(std::move(Err));
2958 if (llvm::Error Err = Stream.SkipBlock()) {
2959 Error(std::move(Err));
2965 case llvm::BitstreamEntry::Record:
2974 Stream.readRecord(Entry.ID,
Record, &Blob);
2975 if (!MaybeRecordType) {
2976 Error(MaybeRecordType.takeError());
2982 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2984 : diag::err_pch_version_too_new);
2988 bool hasErrors =
Record[7];
2989 if (hasErrors && !DisableValidation) {
2992 if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
2993 canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
2996 if (!AllowASTWithCompilerErrors) {
2997 Diag(diag::err_pch_with_compiler_errors);
3002 Diags.ErrorOccurred =
true;
3003 Diags.UncompilableErrorOccurred =
true;
3004 Diags.UnrecoverableErrorOccurred =
true;
3017 StringRef ASTBranch = Blob;
3018 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
3019 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3020 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
3030 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3034 unsigned Idx = 0, N =
Record.size();
3039 bool IsImportingStdCXXModule =
Record[Idx++];
3043 auto [ImportLoc, ImportModuleFileIndex] =
3044 ReadUntranslatedSourceLocation(
Record[Idx++]);
3046 assert(ImportModuleFileIndex == 0);
3047 off_t StoredSize = !IsImportingStdCXXModule ? (off_t)
Record[Idx++] : 0;
3048 time_t StoredModTime =
3049 !IsImportingStdCXXModule ? (time_t)
Record[Idx++] : 0;
3052 if (!IsImportingStdCXXModule) {
3053 auto FirstSignatureByte =
Record.begin() + Idx;
3059 std::string ImportedName = ReadString(
Record, Idx);
3060 std::string ImportedFile;
3069 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
3070 ImportedName, !IsImportingStdCXXModule);
3074 if (!IsImportingStdCXXModule) {
3075 if (ImportedFile.empty()) {
3078 ImportedFile = ReadPath(BaseDirectoryAsWritten,
Record, Idx);
3081 }
else if (ImportedFile.empty()) {
3082 Diag(clang::diag::err_failed_to_find_module_file) << ImportedName;
3088 unsigned Capabilities = ClientLoadCapabilities;
3089 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3090 Capabilities &= ~ARR_Missing;
3093 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
3094 Loaded, StoredSize, StoredModTime,
3095 StoredSignature, Capabilities);
3098 bool recompilingFinalized =
3099 Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
3100 getModuleManager().getModuleCache().isPCMFinal(F.
FileName);
3102 Diag(diag::note_module_file_imported_by)
3104 if (recompilingFinalized)
3105 Diag(diag::note_module_file_conflict);
3108 case Failure:
return Failure;
3111 case OutOfDate:
return OutOfDate;
3113 case ConfigurationMismatch:
return ConfigurationMismatch;
3114 case HadErrors:
return HadErrors;
3134 Diag(diag::remark_module_import)
3136 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
3142 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3150 BaseDirectoryAsWritten = Blob;
3152 "MODULE_DIRECTORY found before MODULE_NAME");
3154 if (!PP.getPreprocessorOpts().ModulesCheckRelocated)
3158 Module *M = PP.getHeaderSearchInfo().lookupModule(
3165 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
3168 auto BuildDir = PP.getFileManager().getOptionalDirectoryRef(Blob);
3169 if (!BuildDir || *BuildDir != M->
Directory) {
3170 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
3171 Diag(diag::err_imported_module_relocated)
3182 if (ASTReadResult
Result =
3183 ReadModuleMapFileBlock(
Record, F, ImportedBy, ClientLoadCapabilities))
3189 NumUserInputs =
Record[1];
3191 (
const llvm::support::unaligned_uint64_t *)Blob.data();
3200llvm::Error ASTReader::ReadASTBlock(
ModuleFile &F,
3201 unsigned ClientLoadCapabilities) {
3202 BitstreamCursor &Stream = F.
Stream;
3204 if (llvm::Error Err = Stream.EnterSubBlock(
AST_BLOCK_ID))
3213 return MaybeEntry.takeError();
3214 llvm::BitstreamEntry Entry = MaybeEntry.get();
3216 switch (Entry.Kind) {
3217 case llvm::BitstreamEntry::Error:
3218 return llvm::createStringError(
3219 std::errc::illegal_byte_sequence,
3220 "error at end of module block in AST file");
3221 case llvm::BitstreamEntry::EndBlock:
3233 return llvm::Error::success();
3234 case llvm::BitstreamEntry::SubBlock:
3242 if (llvm::Error Err = Stream.SkipBlock())
3244 if (llvm::Error Err = ReadBlockAbbrevs(
3251 if (!PP.getExternalSource())
3252 PP.setExternalSource(
this);
3254 if (llvm::Error Err = Stream.SkipBlock())
3256 if (llvm::Error Err =
3265 if (llvm::Error Err = Stream.SkipBlock()) {
3274 if (!PP.getPreprocessingRecord())
3275 PP.createPreprocessingRecord();
3276 if (!PP.getPreprocessingRecord()->getExternalSource())
3277 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3281 if (llvm::Error Err = ReadSourceManagerBlock(F))
3286 if (llvm::Error Err = ReadSubmoduleBlock(F, ClientLoadCapabilities))
3291 BitstreamCursor
C = Stream;
3293 if (llvm::Error Err = Stream.SkipBlock())
3297 CommentsCursors.push_back(std::make_pair(
C, &F));
3302 if (llvm::Error Err = Stream.SkipBlock())
3308 case llvm::BitstreamEntry::Record:
3317 Stream.readRecord(Entry.ID,
Record, &Blob);
3318 if (!MaybeRecordType)
3319 return MaybeRecordType.takeError();
3351 return llvm::createStringError(
3352 std::errc::illegal_byte_sequence,
3353 "duplicate TYPE_OFFSET record in AST file");
3356 unsigned LocalBaseTypeIndex =
Record[1];
3361 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3365 std::make_pair(LocalBaseTypeIndex,
3375 return llvm::createStringError(
3376 std::errc::illegal_byte_sequence,
3377 "duplicate DECL_OFFSET record in AST file");
3380 unsigned LocalBaseDeclID =
Record[1];
3386 GlobalDeclMap.insert(std::make_pair(
3392 std::make_pair(LocalBaseDeclID, F.
BaseDeclID - LocalBaseDeclID));
3404 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3405 LexicalContents Contents(
3406 reinterpret_cast<const unalighed_decl_id_t *
>(Blob.data()),
3407 static_cast<unsigned int>(Blob.size() /
sizeof(
DeclID)));
3408 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3416 auto *
Data = (
const unsigned char*)Blob.data();
3417 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&F,
Data});
3420 if (
Decl *D = GetExistingDecl(ID))
3421 PendingUpdateRecords.push_back(
3422 PendingUpdateRecord(ID, D,
false));
3428 reinterpret_cast<const unsigned char *
>(Blob.data());
3436 PP.getIdentifierTable().setExternalIdentifierLookup(
this);
3442 return llvm::createStringError(
3443 std::errc::illegal_byte_sequence,
3444 "duplicate IDENTIFIER_OFFSET record in AST file");
3447 unsigned LocalBaseIdentifierID =
Record[1];
3453 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3459 std::make_pair(LocalBaseIdentifierID,
3462 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3475 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3476 EagerlyDeserializedDecls.push_back(
3484 getContext().getLangOpts().BuildingPCHWithObjectFile)
3485 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3486 EagerlyDeserializedDecls.push_back(
3491 if (SpecialTypes.empty()) {
3492 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3493 SpecialTypes.push_back(getGlobalTypeID(F,
Record[I]));
3497 if (SpecialTypes.size() !=
Record.size())
3498 return llvm::createStringError(std::errc::illegal_byte_sequence,
3499 "invalid special-types record");
3501 for (
unsigned I = 0, N =
Record.size(); I != N; ++I) {
3503 if (!SpecialTypes[I])
3504 SpecialTypes[I] =
ID;
3511 TotalNumStatements +=
Record[0];
3512 TotalNumMacros +=
Record[1];
3513 TotalLexicalDeclContexts +=
Record[2];
3514 TotalVisibleDeclContexts +=
Record[3];
3518 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3519 UnusedFileScopedDecls.push_back(
3524 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3525 DelegatingCtorDecls.push_back(
3530 if (
Record.size() % 3 != 0)
3531 return llvm::createStringError(std::errc::illegal_byte_sequence,
3532 "invalid weak identifiers record");
3536 WeakUndeclaredIdentifiers.clear();
3539 for (
unsigned I = 0, N =
Record.size(); I < N; ) {
3540 WeakUndeclaredIdentifiers.push_back(
3541 getGlobalIdentifierID(F,
Record[I++]));
3542 WeakUndeclaredIdentifiers.push_back(
3543 getGlobalIdentifierID(F,
Record[I++]));
3544 WeakUndeclaredIdentifiers.push_back(
3545 ReadSourceLocation(F,
Record, I).getRawEncoding());
3552 unsigned LocalBaseSelectorID =
Record[1];
3558 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3563 std::make_pair(LocalBaseSelectorID,
3575 = ASTSelectorLookupTable::Create(
3579 TotalNumMethodPoolEntries +=
Record[1];
3584 for (
unsigned Idx = 0, N =
Record.size() - 1; Idx < N; ) {
3585 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3587 ReferencedSelectorsData.push_back(ReadSourceLocation(F,
Record, Idx).
3596 PP.setPreambleRecordedPragmaAssumeNonNullLoc(
3597 ReadSourceLocation(F,
Record, Idx));
3603 unsigned Idx = 0, End =
Record.size() - 1;
3604 bool ReachedEOFWhileSkipping =
Record[Idx++];
3605 std::optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3606 if (ReachedEOFWhileSkipping) {
3609 bool FoundNonSkipPortion =
Record[Idx++];
3610 bool FoundElse =
Record[Idx++];
3612 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3613 FoundElse, ElseLoc);
3617 auto Loc = ReadSourceLocation(F,
Record, Idx);
3618 bool WasSkipping =
Record[Idx++];
3619 bool FoundNonSkip =
Record[Idx++];
3620 bool FoundElse =
Record[Idx++];
3621 ConditionalStack.push_back(
3622 {
Loc, WasSkipping, FoundNonSkip, FoundElse});
3624 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3629 if (!
Record.empty() && Listener)
3647 if (!Diags.isDiagnosticInFlight()) {
3649 SourceMgr.noteSLocAddressSpaceUsage(Diags);
3651 return llvm::createStringError(std::errc::invalid_argument,
3652 "ran out of source locations");
3657 unsigned RangeStart =
3659 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3664 GlobalSLocOffsetMap.insert(
3666 - SLocSpaceSize,&F));
3677 ParseLineTable(F,
Record);
3681 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3686 if (
Record.size() % 3 != 0)
3687 return llvm::createStringError(std::errc::illegal_byte_sequence,
3688 "Invalid VTABLE_USES record");
3695 for (
unsigned Idx = 0, N =
Record.size(); Idx != N; ) {
3696 VTableUses.push_back(
3698 ReadSourceLocation(F,
Record, Idx).getRawEncoding(),
3705 if (
Record.size() % 2 != 0)
3706 return llvm::createStringError(
3707 std::errc::illegal_byte_sequence,
3708 "Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3710 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3711 PendingInstantiations.push_back(
3713 ReadSourceLocation(F,
Record, I).getRawEncoding()});
3719 return llvm::createStringError(std::errc::illegal_byte_sequence,
3720 "Invalid SEMA_DECL_REFS block");
3721 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3730 unsigned LocalBasePreprocessedEntityID =
Record[0];
3732 unsigned StartingID;
3733 if (!PP.getPreprocessingRecord())
3734 PP.createPreprocessingRecord();
3735 if (!PP.getPreprocessingRecord()->getExternalSource())
3736 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3738 = PP.getPreprocessingRecord()
3745 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3750 std::make_pair(LocalBasePreprocessedEntityID,
3762 if (!PP.getPreprocessingRecord())
3763 PP.createPreprocessingRecord();
3764 if (!PP.getPreprocessingRecord()->getExternalSource())
3765 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3770 GlobalSkippedRangeMap.insert(
3776 if (
Record.size() % 2 != 0)
3777 return llvm::createStringError(
3778 std::errc::illegal_byte_sequence,
3779 "invalid DECL_UPDATE_OFFSETS block in AST file");
3780 for (
unsigned I = 0, N =
Record.size(); I != N; I += 2) {
3782 DeclUpdateOffsets[
ID].push_back(std::make_pair(&F,
Record[I + 1]));
3786 if (
Decl *D = GetExistingDecl(ID))
3787 PendingUpdateRecords.push_back(
3788 PendingUpdateRecord(ID, D,
false));
3793 if (
Record.size() % 3 != 0)
3794 return llvm::createStringError(
3795 std::errc::illegal_byte_sequence,
3796 "invalid DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD block in AST "
3798 for (
unsigned I = 0, N =
Record.size(); I != N; I += 3) {
3802 assert(BaseOffset &&
"Invalid DeclsBlockStartOffset for module file!");
3806 DelayedNamespaceOffsetMap[
ID] = {LexicalOffset, VisibleOffset};
3808 assert(!GetExistingDecl(ID) &&
3809 "We shouldn't load the namespace in the front of delayed "
3810 "namespace lexical and visible block");
3817 return llvm::createStringError(
3818 std::errc::illegal_byte_sequence,
3819 "duplicate OBJC_CATEGORIES_MAP record in AST file");
3832 CUDASpecialDeclRefs.clear();
3833 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3834 CUDASpecialDeclRefs.push_back(
3843 = HeaderFileInfoLookupTable::Create(
3847 &PP.getHeaderSearchInfo(),
3848 Blob.data() +
Record[2]));
3850 PP.getHeaderSearchInfo().SetExternalSource(
this);
3851 if (!PP.getHeaderSearchInfo().getExternalLookup())
3852 PP.getHeaderSearchInfo().SetExternalLookup(
this);
3858 FPPragmaOptions.swap(
Record);
3862 for (
unsigned I = 0, E =
Record.size(); I != E; ) {
3863 auto Name = ReadString(
Record, I);
3864 auto &OptInfo = OpenCLExtensions.OptMap[Name];
3865 OptInfo.Supported =
Record[I++] != 0;
3866 OptInfo.Enabled =
Record[I++] != 0;
3867 OptInfo.WithPragma =
Record[I++] != 0;
3868 OptInfo.Avail =
Record[I++];
3869 OptInfo.Core =
Record[I++];
3870 OptInfo.Opt =
Record[I++];
3875 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3876 TentativeDefinitions.push_back(
3881 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3886 if (
Record.size() % 2 != 0)
3887 return llvm::createStringError(std::errc::illegal_byte_sequence,
3888 "invalid undefined-but-used record");
3889 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3890 UndefinedButUsed.push_back(
3892 ReadSourceLocation(F,
Record, I).getRawEncoding()});
3897 for (
unsigned I = 0, N =
Record.size(); I != N;) {
3898 DelayedDeleteExprs.push_back(
3901 DelayedDeleteExprs.push_back(Count);
3902 for (uint64_t
C = 0;
C < Count; ++
C) {
3903 DelayedDeleteExprs.push_back(ReadSourceLocation(F,
Record, I).getRawEncoding());
3904 bool IsArrayForm =
Record[I++] == 1;
3905 DelayedDeleteExprs.push_back(IsArrayForm);
3915 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3916 unsigned GlobalID = getGlobalSubmoduleID(F,
Record[I++]);
3919 PendingImportedModules.push_back(ImportedSubmodule(GlobalID,
Loc));
3920 if (DeserializationListener)
3921 DeserializationListener->ModuleImportRead(GlobalID,
Loc);
3929 return llvm::createStringError(
3930 std::errc::illegal_byte_sequence,
3931 "duplicate MACRO_OFFSET record in AST file");
3934 unsigned LocalBaseMacroID =
Record[1];
3940 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3944 std::make_pair(LocalBaseMacroID,
3953 LateParsedTemplates.emplace_back(
3954 std::piecewise_construct, std::forward_as_tuple(&F),
3960 return llvm::createStringError(std::errc::illegal_byte_sequence,
3961 "invalid pragma optimize record");
3962 OptimizeOffPragmaLocation = ReadSourceLocation(F,
Record[0]);
3967 return llvm::createStringError(std::errc::illegal_byte_sequence,
3968 "invalid pragma ms_struct record");
3969 PragmaMSStructState =
Record[0];
3974 return llvm::createStringError(
3975 std::errc::illegal_byte_sequence,
3976 "invalid pragma pointers to members record");
3977 PragmaMSPointersToMembersState =
Record[0];
3978 PointersToMembersPragmaLocation = ReadSourceLocation(F,
Record[1]);
3982 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3983 UnusedLocalTypedefNameCandidates.push_back(
3989 return llvm::createStringError(std::errc::illegal_byte_sequence,
3990 "invalid cuda pragma options record");
3991 ForceHostDeviceDepth =
Record[0];
3996 return llvm::createStringError(std::errc::illegal_byte_sequence,
3997 "invalid pragma pack record");
3998 PragmaAlignPackCurrentValue = ReadAlignPackInfo(
Record[0]);
3999 PragmaAlignPackCurrentLocation = ReadSourceLocation(F,
Record[1]);
4000 unsigned NumStackEntries =
Record[2];
4003 PragmaAlignPackStack.clear();
4004 for (
unsigned I = 0; I < NumStackEntries; ++I) {
4005 PragmaAlignPackStackEntry Entry;
4006 Entry.Value = ReadAlignPackInfo(
Record[Idx++]);
4007 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
4008 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
4009 PragmaAlignPackStrings.push_back(ReadString(
Record, Idx));
4010 Entry.SlotLabel = PragmaAlignPackStrings.back();
4011 PragmaAlignPackStack.push_back(Entry);
4018 return llvm::createStringError(std::errc::illegal_byte_sequence,
4019 "invalid pragma float control record");
4021 FpPragmaCurrentLocation = ReadSourceLocation(F,
Record[1]);
4022 unsigned NumStackEntries =
Record[2];
4025 FpPragmaStack.clear();
4026 for (
unsigned I = 0; I < NumStackEntries; ++I) {
4027 FpPragmaStackEntry Entry;
4029 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
4030 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
4031 FpPragmaStrings.push_back(ReadString(
Record, Idx));
4032 Entry.SlotLabel = FpPragmaStrings.back();
4033 FpPragmaStack.push_back(Entry);
4039 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
4040 DeclsToCheckForDeferredDiags.insert(
4047void ASTReader::ReadModuleOffsetMap(
ModuleFile &F)
const {
4065 assert(ImportedModuleVector.empty());
4067 while (
Data < DataEnd) {
4071 using namespace llvm::support;
4073 endian::readNext<uint8_t, llvm::endianness::little>(
Data));
4074 uint16_t Len = endian::readNext<uint16_t, llvm::endianness::little>(
Data);
4075 StringRef Name = StringRef((
const char*)
Data, Len);
4079 ? ModuleMgr.lookupByModuleName(Name)
4080 : ModuleMgr.lookupByFileName(Name));
4082 std::string Msg =
"refers to unknown module, cannot find ";
4083 Msg.append(std::string(Name));
4088 ImportedModuleVector.push_back(OM);
4090 uint32_t IdentifierIDOffset =
4091 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4092 uint32_t MacroIDOffset =
4093 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4094 uint32_t PreprocessedEntityIDOffset =
4095 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4096 uint32_t SubmoduleIDOffset =
4097 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4098 uint32_t SelectorIDOffset =
4099 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4100 uint32_t DeclIDOffset =
4101 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4102 uint32_t TypeIndexOffset =
4103 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4105 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
4106 RemapBuilder &Remap) {
4107 constexpr uint32_t
None = std::numeric_limits<uint32_t>::max();
4109 Remap.insert(std::make_pair(Offset,
4110 static_cast<int>(BaseOffset - Offset)));
4114 mapOffset(MacroIDOffset, OM->
BaseMacroID, MacroRemap);
4116 PreprocessedEntityRemap);
4119 mapOffset(DeclIDOffset, OM->
BaseDeclID, DeclRemap);
4130 unsigned ClientLoadCapabilities) {
4139 "MODULE_NAME should come before MODULE_MAP_FILE");
4140 if (PP.getPreprocessorOpts().ModulesCheckRelocated &&
4146 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
4148 M ? Map.getModuleMapFileForUniquing(M) : std::nullopt;
4150 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
4153 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities)) {
4154 if (
auto ASTFE = M ? M->
getASTFile() : std::nullopt) {
4157 << ASTFE->getName();
4160 Diag(diag::err_imported_module_not_found)
4168 Diag(diag::note_imported_by_pch_module_not_found)
4175 assert(M && M->
Name == F.
ModuleName &&
"found module with different name");
4179 if (!StoredModMap || *StoredModMap != ModMap) {
4180 assert(ModMap &&
"found module is missing module map file");
4182 "top-level import should be verified");
4184 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4185 Diag(diag::err_imported_module_modmap_changed)
4192 for (
unsigned I = 0, N =
Record[Idx++]; I < N; ++I) {
4197 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4198 Error(
"could not find file '" +
Filename +
"' referenced by AST file");
4201 AdditionalStoredMaps.insert(*SF);
4206 if (
auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
4210 if (!AdditionalStoredMaps.erase(ModMap)) {
4211 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4212 Diag(diag::err_module_different_modmap)
4222 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4223 Diag(diag::err_module_different_modmap)
4244 : Known->second.second;
4246 for (
ObjCMethodList *List = &Start; List; List = List->getNext()) {
4248 if (List->getMethod() == Method) {
4256 if (List->getNext())
4257 List->setMethod(List->getNext()->getMethod());
4259 List->setMethod(Method);
4265 for (
Decl *D : Names) {
4266 bool wasHidden = !D->isUnconditionallyVisible();
4267 D->setVisibleDespiteOwningModule();
4269 if (wasHidden && SemaObj) {
4282 Stack.push_back(Mod);
4283 while (!Stack.empty()) {
4284 Mod = Stack.pop_back_val();
4286 if (NameVisibility <= Mod->NameVisibility) {
4302 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4303 if (Hidden != HiddenNamesMap.end()) {
4305 HiddenNamesMap.erase(Hidden);
4307 assert(!HiddenNamesMap.contains(Mod) &&
4308 "making names visible added hidden names");
4315 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4317 if (
Visited.insert(Exported).second)
4318 Stack.push_back(Exported);
4333 getContext().mergeDefinitionIntoModule(
4336 PendingMergedDefinitionsToDeduplicate.insert(Def);
4345 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4346 !PP.getLangOpts().Modules)
4350 TriedLoadingGlobalIndex =
true;
4351 StringRef ModuleCachePath
4352 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4353 std::pair<GlobalModuleIndex *, llvm::Error>
Result =
4355 if (llvm::Error Err = std::move(
Result.second)) {
4357 consumeError(std::move(Err));
4361 GlobalIndex.reset(
Result.first);
4362 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4367 return PP.getLangOpts().Modules && UseGlobalIndex &&
4368 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4375 llvm::raw_fd_ostream OS(TimestampFilename, EC,
4376 llvm::sys::fs::OF_TextWithCRLF);
4379 OS <<
"Timestamp file\n";
4392 consumeError(MaybeEntry.takeError());
4395 llvm::BitstreamEntry Entry = MaybeEntry.get();
4397 switch (Entry.Kind) {
4398 case llvm::BitstreamEntry::Error:
4399 case llvm::BitstreamEntry::EndBlock:
4402 case llvm::BitstreamEntry::Record:
4408 consumeError(Skipped.takeError());
4412 case llvm::BitstreamEntry::SubBlock:
4413 if (Entry.ID == BlockID) {
4414 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4416 consumeError(std::move(Err));
4423 if (llvm::Error Err = Cursor.SkipBlock()) {
4425 consumeError(std::move(Err));
4434 unsigned ClientLoadCapabilities,
4436 llvm::TimeTraceScope scope(
"ReadAST",
FileName);
4440 CurrentDeserializingModuleKind,
Type);
4446 unsigned PreviousGeneration = 0;
4448 PreviousGeneration = incrementGeneration(*ContextObj);
4450 unsigned NumModules = ModuleMgr.size();
4455 ClientLoadCapabilities)) {
4456 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules);
4460 GlobalIndex.reset();
4461 ModuleMgr.setGlobalIndex(
nullptr);
4465 if (NewLoadedModuleFile && !Loaded.empty())
4466 *NewLoadedModuleFile = Loaded.back().Mod;
4477 for (ImportedModule &M : Loaded) {
4479 llvm::TimeTraceScope Scope2(
"Read Loaded AST", F.
ModuleName);
4482 if (llvm::Error Err = ReadASTBlock(F, ClientLoadCapabilities)) {
4483 Error(std::move(Err));
4489 Error(diag::err_module_file_missing_top_level_submodule, F.
FileName);
4495 if (llvm::Error Err = ReadExtensionBlock(F)) {
4496 Error(std::move(Err));
4509 for (ImportedModule &M : Loaded) {
4525 if (!PP.getLangOpts().CPlusPlus) {
4532 auto It = PP.getIdentifierTable().find(Key);
4533 if (It == PP.getIdentifierTable().end())
4542 II = &PP.getIdentifierTable().getOwn(Key);
4553 SetIdentifierInfo(ID, II);
4560 for (
auto &
Id : PP.getIdentifierTable())
4561 Id.second->setOutOfDate(
true);
4564 for (
const auto &Sel : SelectorGeneration)
4565 SelectorOutOfDate[Sel.first] =
true;
4569 for (ImportedModule &M : Loaded) {
4572 ModuleMgr.moduleFileAccepted(&F);
4581 F.
ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4585 for (
unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4586 UnresolvedModuleRef &
Unresolved = UnresolvedModuleRefs[I];
4588 Module *ResolvedMod = getSubmodule(GlobalID);
4591 case UnresolvedModuleRef::Conflict:
4594 Conflict.
Other = ResolvedMod;
4596 Unresolved.Mod->Conflicts.push_back(Conflict);
4600 case UnresolvedModuleRef::Import:
4605 case UnresolvedModuleRef::Affecting:
4607 Unresolved.Mod->AffectingClangModules.insert(ResolvedMod);
4610 case UnresolvedModuleRef::Export:
4617 UnresolvedModuleRefs.clear();
4624 InitializeContext();
4629 if (DeserializationListener)
4630 DeserializationListener->ReaderInitialized(
this);
4632 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4647 for (
unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4648 loadObjCCategories(
GlobalDeclID(ObjCClassesLoaded[I]->getGlobalID()),
4649 ObjCClassesLoaded[I], PreviousGeneration);
4658 for (
unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4659 ImportedModule &M = Loaded[I];
4676 if (!Stream.canSkipToPos(4))
4677 return llvm::createStringError(std::errc::illegal_byte_sequence,
4678 "file too small to contain AST file magic");
4679 for (
unsigned C : {
'C',
'P',
'C',
'H'})
4682 return llvm::createStringError(
4683 std::errc::illegal_byte_sequence,
4684 "file doesn't start with AST file magic");
4686 return Res.takeError();
4687 return llvm::Error::success();
4702 llvm_unreachable(
"unknown module kind");
4706ASTReader::ReadASTCore(StringRef
FileName,
4711 off_t ExpectedSize, time_t ExpectedModTime,
4713 unsigned ClientLoadCapabilities) {
4715 std::string ErrorStr;
4717 = ModuleMgr.addModule(
FileName,
Type, ImportLoc, ImportedBy,
4718 getGeneration(), ExpectedSize, ExpectedModTime,
4722 switch (AddResult) {
4724 Diag(diag::remark_module_import)
4726 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
4736 if (ClientLoadCapabilities & ARR_Missing)
4740 Diag(diag::err_ast_file_not_found)
4748 if (ClientLoadCapabilities & ARR_OutOfDate)
4752 Diag(diag::err_ast_file_out_of_date)
4758 assert(M &&
"Missing module file");
4760 bool ShouldFinalizePCM =
false;
4761 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4762 auto &MC = getModuleManager().getModuleCache();
4763 if (ShouldFinalizePCM)
4769 BitstreamCursor &Stream = F.
Stream;
4770 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4771 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4775 Diag(diag::err_ast_file_invalid)
4781 bool HaveReadControlBlock =
false;
4785 Error(MaybeEntry.takeError());
4788 llvm::BitstreamEntry Entry = MaybeEntry.get();
4790 switch (Entry.Kind) {
4791 case llvm::BitstreamEntry::Error:
4792 case llvm::BitstreamEntry::Record:
4793 case llvm::BitstreamEntry::EndBlock:
4794 Error(
"invalid record at top-level of AST file");
4797 case llvm::BitstreamEntry::SubBlock:
4803 HaveReadControlBlock =
true;
4804 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4812 F.ModuleName.empty()) {
4814 if (
Result != OutOfDate ||
4815 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4821 case Failure:
return Failure;
4822 case Missing:
return Missing;
4823 case OutOfDate:
return OutOfDate;
4825 case ConfigurationMismatch:
return ConfigurationMismatch;
4826 case HadErrors:
return HadErrors;
4831 if (!HaveReadControlBlock) {
4832 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4833 Diag(diag::err_pch_version_too_old);
4838 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4839 ShouldFinalizePCM =
true;
4843 if (llvm::Error Err = Stream.SkipBlock()) {
4844 Error(std::move(Err));
4851 llvm_unreachable(
"unexpected break; expected return");
4855ASTReader::readUnhashedControlBlock(
ModuleFile &F,
bool WasImportedBy,
4856 unsigned ClientLoadCapabilities) {
4858 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4859 bool AllowCompatibleConfigurationMismatch =
4861 bool DisableValidation = shouldDisableValidationForFile(F);
4863 ASTReadResult
Result = readUnhashedControlBlockImpl(
4864 &F, F.
Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4870 if (DisableValidation || WasImportedBy ||
4871 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
4875 Error(
"malformed block record in AST file");
4898 if (getModuleManager().getModuleCache().isPCMFinal(F.
FileName)) {
4899 Diag(diag::warn_module_system_bit_conflict) << F.
FileName;
4908 ModuleFile *F, llvm::StringRef StreamData,
unsigned ClientLoadCapabilities,
4910 bool ValidateDiagnosticOptions) {
4912 BitstreamCursor Stream(StreamData);
4917 consumeError(std::move(Err));
4932 consumeError(MaybeEntry.takeError());
4935 llvm::BitstreamEntry Entry = MaybeEntry.get();
4937 switch (Entry.Kind) {
4938 case llvm::BitstreamEntry::Error:
4939 case llvm::BitstreamEntry::SubBlock:
4942 case llvm::BitstreamEntry::EndBlock:
4945 case llvm::BitstreamEntry::Record:
4954 Stream.readRecord(Entry.ID,
Record, &Blob);
4955 if (!MaybeRecordType) {
4964 "Dummy AST file signature not backpatched in ASTWriter.");
4971 "Dummy AST block hash not backpatched in ASTWriter.");
4975 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4976 if (Listener && ValidateDiagnosticOptions &&
4977 !AllowCompatibleConfigurationMismatch &&
4978 ParseDiagnosticOptions(
Record, Complain, *Listener))
4983 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
4984 if (Listener && !AllowCompatibleConfigurationMismatch &&
4985 ParseHeaderSearchPaths(
Record, Complain, *Listener))
4986 Result = ConfigurationMismatch;
5015 if (
Record.size() < 4)
return true;
5020 unsigned BlockNameLen =
Record[2];
5021 unsigned UserInfoLen =
Record[3];
5023 if (BlockNameLen + UserInfoLen > Blob.size())
return true;
5025 Metadata.
BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
5026 Metadata.
UserInfo = std::string(Blob.data() + BlockNameLen,
5027 Blob.data() + BlockNameLen + UserInfoLen);
5031llvm::Error ASTReader::ReadExtensionBlock(
ModuleFile &F) {
5032 BitstreamCursor &Stream = F.
Stream;
5038 return MaybeEntry.takeError();
5039 llvm::BitstreamEntry Entry = MaybeEntry.get();
5041 switch (Entry.Kind) {
5042 case llvm::BitstreamEntry::SubBlock:
5043 if (llvm::Error Err = Stream.SkipBlock())
5046 case llvm::BitstreamEntry::EndBlock:
5047 return llvm::Error::success();
5048 case llvm::BitstreamEntry::Error:
5049 return llvm::createStringError(std::errc::illegal_byte_sequence,
5050 "malformed block record in AST file");
5051 case llvm::BitstreamEntry::Record:
5058 Stream.readRecord(Entry.ID,
Record, &Blob);
5060 return MaybeRecCode.takeError();
5061 switch (MaybeRecCode.get()) {
5065 return llvm::createStringError(
5066 std::errc::illegal_byte_sequence,
5067 "malformed EXTENSION_METADATA in AST file");
5070 auto Known = ModuleFileExtensions.find(Metadata.
BlockName);
5071 if (Known == ModuleFileExtensions.end())
break;
5074 if (
auto Reader = Known->second->createExtensionReader(Metadata, *
this,
5084 return llvm::Error::success();
5088 assert(ContextObj &&
"no context to initialize");
5092 if (DeserializationListener)
5093 DeserializationListener->DeclRead(
5103 if (!Context.CFConstantStringTypeDecl)
5110 Error(
"FILE type is NULL");
5114 if (!Context.FILEDecl) {
5120 Error(
"Invalid FILE type in AST file");
5129 QualType Jmp_bufType = GetType(Jmp_buf);
5130 if (Jmp_bufType.
isNull()) {
5131 Error(
"jmp_buf type is NULL");
5135 if (!Context.jmp_bufDecl) {
5141 Error(
"Invalid jmp_buf type in AST file");
5150 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
5151 if (Sigjmp_bufType.
isNull()) {
5152 Error(
"sigjmp_buf type is NULL");
5156 if (!Context.sigjmp_bufDecl) {
5161 assert(Tag &&
"Invalid sigjmp_buf type in AST file");
5167 if (
unsigned ObjCIdRedef
5169 if (Context.ObjCIdRedefinitionType.
isNull())
5170 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
5173 if (
unsigned ObjCClassRedef
5175 if (Context.ObjCClassRedefinitionType.
isNull())
5176 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
5179 if (
unsigned ObjCSelRedef
5181 if (Context.ObjCSelRedefinitionType.
isNull())
5182 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
5186 QualType Ucontext_tType = GetType(Ucontext_t);
5187 if (Ucontext_tType.
isNull()) {
5188 Error(
"ucontext_t type is NULL");
5192 if (!Context.ucontext_tDecl) {
5197 assert(Tag &&
"Invalid ucontext_t type in AST file");
5207 if (!CUDASpecialDeclRefs.empty()) {
5208 assert(CUDASpecialDeclRefs.size() == 1 &&
"More decl refs than expected!");
5210 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5215 for (
auto &Import : PendingImportedModules) {
5216 if (
Module *Imported = getSubmodule(Import.ID)) {
5219 if (Import.ImportLoc.isValid())
5220 PP.makeModuleVisible(Imported, Import.ImportLoc);
5227 PendingImportedModulesSema.append(PendingImportedModules);
5228 PendingImportedModules.clear();
5238 BitstreamCursor Stream(
PCH);
5241 consumeError(std::move(Err));
5253 Stream.advanceSkippingSubblocks();
5256 consumeError(MaybeEntry.takeError());
5259 llvm::BitstreamEntry Entry = MaybeEntry.get();
5261 if (Entry.Kind != llvm::BitstreamEntry::Record)
5269 consumeError(MaybeRecord.takeError());
5275 "Dummy AST file signature not backpatched in ASTWriter.");
5285 const std::string &ASTFileName,
FileManager &FileMgr,
5291 Diags.
Report(diag::err_fe_unable_to_read_pch_file)
5292 << ASTFileName << Buffer.getError().message();
5293 return std::string();
5297 BitstreamCursor Stream(PCHContainerRdr.
ExtractPCH(**Buffer));
5301 Diags.
Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5302 return std::string();
5307 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5308 return std::string();
5315 Stream.advanceSkippingSubblocks();
5318 consumeError(MaybeEntry.takeError());
5319 return std::string();
5321 llvm::BitstreamEntry Entry = MaybeEntry.get();
5323 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5324 return std::string();
5326 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5327 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5328 return std::string();
5336 consumeError(MaybeRecord.takeError());
5337 return std::string();
5350 std::string ExistingModuleCachePath;
5352 bool StrictOptionMatches;
5355 SimplePCHValidator(
const LangOptions &ExistingLangOpts,
5358 StringRef ExistingModuleCachePath,
FileManager &FileMgr,
5359 bool StrictOptionMatches)
5360 : ExistingLangOpts(ExistingLangOpts),
5361 ExistingTargetOpts(ExistingTargetOpts),
5362 ExistingPPOpts(ExistingPPOpts),
5363 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr),
5364 StrictOptionMatches(StrictOptionMatches) {}
5366 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
5367 bool AllowCompatibleDifferences)
override {
5369 AllowCompatibleDifferences);
5372 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
5373 bool AllowCompatibleDifferences)
override {
5375 AllowCompatibleDifferences);
5379 StringRef SpecificModuleCachePath,
5380 bool Complain)
override {
5383 ExistingModuleCachePath,
nullptr, ExistingLangOpts, ExistingPPOpts);
5387 bool ReadMacros,
bool Complain,
5388 std::string &SuggestedPredefines)
override {
5390 PPOpts, ExistingPPOpts, ReadMacros,
nullptr, FileMgr,
5391 SuggestedPredefines, ExistingLangOpts,
5404 unsigned ClientLoadCapabilities) {
5406 std::unique_ptr<llvm::MemoryBuffer> OwnedBuffer;
5418 OwnedBuffer = std::move(*BufferOrErr);
5419 Buffer = OwnedBuffer.get();
5423 StringRef Bytes = PCHContainerRdr.
ExtractPCH(*Buffer);
5424 BitstreamCursor Stream(Bytes);
5428 consumeError(std::move(Err));
5439 BitstreamCursor InputFilesCursor;
5440 uint64_t InputFilesOffsetBase = 0;
5443 std::string ModuleDir;
5444 bool DoneWithControlBlock =
false;
5445 while (!DoneWithControlBlock) {
5449 consumeError(MaybeEntry.takeError());
5452 llvm::BitstreamEntry Entry = MaybeEntry.get();
5454 switch (Entry.Kind) {
5455 case llvm::BitstreamEntry::SubBlock: {
5458 std::string IgnoredSuggestedPredefines;
5459 if (ReadOptionsBlock(Stream, ClientLoadCapabilities,
5461 Listener, IgnoredSuggestedPredefines) !=
Success)
5467 InputFilesCursor = Stream;
5468 if (llvm::Error Err = Stream.SkipBlock()) {
5470 consumeError(std::move(Err));
5473 if (NeedsInputFiles &&
5476 InputFilesOffsetBase = InputFilesCursor.GetCurrentBitNo();
5480 if (llvm::Error Err = Stream.SkipBlock()) {
5482 consumeError(std::move(Err));
5491 case llvm::BitstreamEntry::EndBlock:
5492 DoneWithControlBlock =
true;
5495 case llvm::BitstreamEntry::Error:
5498 case llvm::BitstreamEntry::Record:
5502 if (DoneWithControlBlock)
break;
5507 Stream.readRecord(Entry.ID,
Record, &Blob);
5508 if (!MaybeRecCode) {
5523 ModuleDir = std::string(Blob);
5527 auto Path = ReadString(
Record, Idx);
5528 ResolveImportedPath(Path, ModuleDir);
5533 if (!NeedsInputFiles)
5536 unsigned NumInputFiles =
Record[0];
5537 unsigned NumUserFiles =
Record[1];
5538 const llvm::support::unaligned_uint64_t *InputFileOffs =
5539 (
const llvm::support::unaligned_uint64_t *)Blob.data();
5540 for (
unsigned I = 0; I != NumInputFiles; ++I) {
5542 bool isSystemFile = I >= NumUserFiles;
5544 if (isSystemFile && !NeedsSystemInputFiles)
5547 BitstreamCursor &Cursor = InputFilesCursor;
5549 if (llvm::Error Err =
5550 Cursor.JumpToBit(InputFilesOffsetBase + InputFileOffs[I])) {
5552 consumeError(std::move(Err));
5558 consumeError(MaybeCode.takeError());
5560 unsigned Code = MaybeCode.get();
5564 bool shouldContinue =
false;
5566 Cursor.readRecord(Code,
Record, &Blob);
5567 if (!MaybeRecordType) {
5569 consumeError(MaybeRecordType.takeError());
5575 bool Overridden =
static_cast<bool>(
Record[3]);
5576 std::string
Filename = std::string(Blob);
5577 ResolveImportedPath(
Filename, ModuleDir);
5579 Filename, isSystemFile, Overridden,
false);
5582 if (!shouldContinue)
5592 unsigned Idx = 0, N =
Record.size();
5598 bool IsStandardCXXModule =
Record[Idx++];
5605 if (IsStandardCXXModule) {
5606 std::string ModuleName = ReadString(
Record, Idx);
5613 std::string ModuleName = ReadString(
Record, Idx);
5615 ResolveImportedPath(
Filename, ModuleDir);
5628 if (FindModuleFileExtensions) {
5629 BitstreamCursor SavedStream = Stream;
5631 bool DoneWithExtensionBlock =
false;
5632 while (!DoneWithExtensionBlock) {
5638 llvm::BitstreamEntry Entry = MaybeEntry.get();
5640 switch (Entry.Kind) {
5641 case llvm::BitstreamEntry::SubBlock:
5642 if (llvm::Error Err = Stream.SkipBlock()) {
5644 consumeError(std::move(Err));
5649 case llvm::BitstreamEntry::EndBlock:
5650 DoneWithExtensionBlock =
true;
5653 case llvm::BitstreamEntry::Error:
5656 case llvm::BitstreamEntry::Record:
5663 Stream.readRecord(Entry.ID,
Record, &Blob);
5664 if (!MaybeRecCode) {
5668 switch (MaybeRecCode.get()) {
5680 Stream = SavedStream;
5684 if (readUnhashedControlBlockImpl(
5685 nullptr, Bytes, ClientLoadCapabilities,
5687 ValidateDiagnosticOptions) !=
Success)
5699 StringRef ExistingModuleCachePath,
5700 bool RequireStrictOptionMatches) {
5701 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
5702 ExistingModuleCachePath, FileMgr,
5703 RequireStrictOptionMatches);
5704 return !readASTFileControlBlock(
Filename, FileMgr, ModuleCache,
5710llvm::Error ASTReader::ReadSubmoduleBlock(
ModuleFile &F,
5711 unsigned ClientLoadCapabilities) {
5716 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5718 Module *CurrentModule =
nullptr;
5722 F.
Stream.advanceSkippingSubblocks();
5724 return MaybeEntry.takeError();
5725 llvm::BitstreamEntry Entry = MaybeEntry.get();
5727 switch (Entry.Kind) {
5728 case llvm::BitstreamEntry::SubBlock:
5729 case llvm::BitstreamEntry::Error:
5730 return llvm::createStringError(std::errc::illegal_byte_sequence,
5731 "malformed block record in AST file");
5732 case llvm::BitstreamEntry::EndBlock:
5733 return llvm::Error::success();
5734 case llvm::BitstreamEntry::Record:
5744 return MaybeKind.takeError();
5745 unsigned Kind = MaybeKind.get();
5748 return llvm::createStringError(
5749 std::errc::illegal_byte_sequence,
5750 "submodule metadata record should be at beginning of block");
5765 return llvm::createStringError(std::errc::illegal_byte_sequence,
5766 "malformed module definition");
5768 StringRef Name = Blob;
5774 bool IsFramework =
Record[Idx++];
5775 bool IsExplicit =
Record[Idx++];
5776 bool IsSystem =
Record[Idx++];
5777 bool IsExternC =
Record[Idx++];
5778 bool InferSubmodules =
Record[Idx++];
5779 bool InferExplicitSubmodules =
Record[Idx++];
5780 bool InferExportWildcard =
Record[Idx++];
5781 bool ConfigMacrosExhaustive =
Record[Idx++];
5782 bool ModuleMapIsPrivate =
Record[Idx++];
5783 bool NamedModuleHasInit =
Record[Idx++];
5785 Module *ParentModule =
nullptr;
5787 ParentModule = getSubmodule(
Parent);
5798 if (GlobalIndex >= SubmodulesLoaded.size() ||
5799 SubmodulesLoaded[GlobalIndex])
5800 return llvm::createStringError(std::errc::invalid_argument,
5801 "too many submodules");
5803 if (!ParentModule) {
5806 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
5808 CurFile != F.
File) {
5809 auto ConflictError =
5811 ContextObj->DiagAllocator)
5835 if (DeserializationListener)
5836 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5838 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5863 std::string
Filename = std::string(Blob);
5865 if (
auto Umbrella = PP.getFileManager().getOptionalFileRef(
Filename)) {
5893 std::string HeaderName(Blob);
5894 ResolveImportedPath(F, HeaderName);
5901 std::string Dirname = std::string(Blob);
5902 ResolveImportedPath(F, Dirname);
5904 PP.getFileManager().getOptionalDirectoryRef(Dirname)) {
5916 unsigned LocalBaseSubmoduleID =
Record[1];
5920 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5925 std::make_pair(LocalBaseSubmoduleID,
5934 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5939 Unresolved.Kind = UnresolvedModuleRef::Import;
5946 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5951 Unresolved.Kind = UnresolvedModuleRef::Affecting;
5958 for (
unsigned Idx = 0; Idx + 1 <
Record.size(); Idx += 2) {
5963 Unresolved.Kind = UnresolvedModuleRef::Export;
5975 PP.getTargetInfo());
5993 Unresolved.Kind = UnresolvedModuleRef::Conflict;
6005 Inits.push_back(getGlobalDeclID(F,
LocalDeclID(ID)));
6006 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
6025bool ASTReader::ParseLanguageOptions(
const RecordData &
Record,
6028 bool AllowCompatibleDifferences) {
6031#define LANGOPT(Name, Bits, Default, Description) \
6032 LangOpts.Name = Record[Idx++];
6033#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
6034 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
6035#include "clang/Basic/LangOptions.def"
6036#define SANITIZER(NAME, ID) \
6037 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
6038#include "clang/Basic/Sanitizers.def"
6040 for (
unsigned N =
Record[Idx++]; N; --N)
6044 VersionTuple runtimeVersion = ReadVersionTuple(
Record, Idx);
6050 for (
unsigned N =
Record[Idx++]; N; --N) {
6052 ReadString(
Record, Idx));
6057 for (
unsigned N =
Record[Idx++]; N; --N) {
6064 AllowCompatibleDifferences);
6067bool ASTReader::ParseTargetOptions(
const RecordData &
Record,
bool Complain,
6069 bool AllowCompatibleDifferences) {
6073 TargetOpts.
CPU = ReadString(
Record, Idx);
6075 TargetOpts.
ABI = ReadString(
Record, Idx);
6076 for (
unsigned N =
Record[Idx++]; N; --N) {
6079 for (
unsigned N =
Record[Idx++]; N; --N) {
6084 AllowCompatibleDifferences);
6087bool ASTReader::ParseDiagnosticOptions(
const RecordData &
Record,
bool Complain,
6091#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
6092#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
6093 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
6094#include "clang/Basic/DiagnosticOptions.def"
6096 for (
unsigned N =
Record[Idx++]; N; --N)
6097 DiagOpts->Warnings.push_back(ReadString(
Record, Idx));
6098 for (
unsigned N =
Record[Idx++]; N; --N)
6099 DiagOpts->Remarks.push_back(ReadString(
Record, Idx));
6104bool ASTReader::ParseFileSystemOptions(
const RecordData &
Record,
bool Complain,
6112bool ASTReader::ParseHeaderSearchOptions(
const RecordData &
Record,
6130 std::string SpecificModuleCachePath = ReadString(
Record, Idx);
6136bool ASTReader::ParseHeaderSearchPaths(
const RecordData &
Record,
bool Complain,
6142 for (
unsigned N =
Record[Idx++]; N; --N) {
6143 std::string Path = ReadString(
Record, Idx);
6146 bool IsFramework =
Record[Idx++];
6147 bool IgnoreSysRoot =
Record[Idx++];
6153 for (
unsigned N =
Record[Idx++]; N; --N) {
6154 std::string Prefix = ReadString(
Record, Idx);
6155 bool IsSystemHeader =
Record[Idx++];
6160 for (
unsigned N =
Record[Idx++]; N; --N) {
6161 std::string VFSOverlayFile = ReadString(
Record, Idx);
6168bool ASTReader::ParsePreprocessorOptions(
const RecordData &
Record,
6171 std::string &SuggestedPredefines) {
6176 bool ReadMacros =
Record[Idx++];
6178 for (
unsigned N =
Record[Idx++]; N; --N) {
6180 bool IsUndef =
Record[Idx++];
6181 PPOpts.
Macros.push_back(std::make_pair(Macro, IsUndef));
6186 for (
unsigned N =
Record[Idx++]; N; --N) {
6191 for (
unsigned N =
Record[Idx++]; N; --N) {
6200 SuggestedPredefines.clear();
6202 SuggestedPredefines);
6205std::pair<ModuleFile *, unsigned>
6206ASTReader::getModulePreprocessedEntity(
unsigned GlobalIndex) {
6207 GlobalPreprocessedEntityMapType::iterator
6208 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
6209 assert(I != GlobalPreprocessedEntityMap.end() &&
6210 "Corrupted global preprocessed entity map");
6213 return std::make_pair(M, LocalIndex);
6216llvm::iterator_range<PreprocessingRecord::iterator>
6217ASTReader::getModulePreprocessedEntities(
ModuleFile &Mod)
const {
6226bool ASTReader::canRecoverFromOutOfDate(StringRef ModuleFileName,
6227 unsigned int ClientLoadCapabilities) {
6228 return ClientLoadCapabilities & ARR_OutOfDate &&
6229 !getModuleManager().getModuleCache().isPCMFinal(ModuleFileName);
6232llvm::iterator_range<ASTReader::ModuleDeclIterator>
6234 return llvm::make_range(
6241 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
6242 assert(I != GlobalSkippedRangeMap.end() &&
6243 "Corrupted global skipped range map");
6246 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
6249 ReadSourceLocation(*M, RawRange.
getEnd()));
6256 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6258 unsigned LocalIndex = PPInfo.second;
6261 if (!PP.getPreprocessingRecord()) {
6262 Error(
"no preprocessing record");
6269 Error(std::move(Err));
6276 Error(MaybeEntry.takeError());
6279 llvm::BitstreamEntry Entry = MaybeEntry.get();
6281 if (Entry.Kind != llvm::BitstreamEntry::Record)
6286 ReadSourceLocation(M, PPOffs.
getEnd()));
6292 if (!MaybeRecType) {
6293 Error(MaybeRecType.takeError());
6298 bool isBuiltin =
Record[0];
6302 Name = getLocalIdentifier(M,
Record[1]);
6305 getGlobalPreprocessedEntityID(M,
Record[1]);
6306 Def = cast<MacroDefinitionRecord>(
6307 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
6325 if (DeserializationListener)
6326 DeserializationListener->MacroDefinitionRead(PPID, MD);
6332 const char *FullFileNameStart = Blob.data() +
Record[0];
6333 StringRef FullFileName(FullFileNameStart, Blob.size() -
Record[0]);
6335 if (!FullFileName.empty())
6336 File = PP.getFileManager().getOptionalFileRef(FullFileName);
6343 StringRef(Blob.data(),
Record[0]),
6351 llvm_unreachable(
"Invalid PreprocessorDetailRecordTypes");
6361 GlobalSLocOffsetMapType::const_iterator SLocMapI)
const {
6363 for (GlobalSLocOffsetMapType::const_iterator
6364 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
6370 return getTotalNumPreprocessedEntities();
6375struct PPEntityComp {
6405 bool EndsAfter)
const {
6406 if (SourceMgr.isLocalSourceLocation(
Loc))
6407 return getTotalNumPreprocessedEntities();
6409 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
6410 SourceManager::MaxLoadedOffset -
Loc.getOffset() - 1);
6411 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
6412 "Corrupted global sloc offset map");
6414 if (SLocMapI->second->NumPreprocessedEntities == 0)
6415 return findNextPreprocessedEntity(SLocMapI);
6426 pp_iterator
First = pp_begin;
6430 PPI = std::upper_bound(pp_begin, pp_end,
Loc,
6431 PPEntityComp(*
this, M));
6440 std::advance(PPI,
Half);
6441 if (SourceMgr.isBeforeInTranslationUnit(
6442 ReadSourceLocation(M, PPI->getEnd()),
Loc)) {
6445 Count = Count -
Half - 1;
6452 return findNextPreprocessedEntity(SLocMapI);
6459std::pair<unsigned, unsigned>
6462 return std::make_pair(0,0);
6468 return std::make_pair(BeginID, EndID);
6478 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6480 unsigned LocalIndex = PPInfo.second;
6487 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(
Loc), FID))
6496 class HeaderFileInfoVisitor {
6498 std::optional<HeaderFileInfo> HFI;
6501 explicit HeaderFileInfoVisitor(
FileEntryRef FE) : FE(FE) {}
6510 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
6511 if (Pos == Table->end())
6518 std::optional<HeaderFileInfo> getHeaderFileInfo()
const {
return HFI; }
6524 HeaderFileInfoVisitor Visitor(FE);
6525 ModuleMgr.visit(Visitor);
6526 if (std::optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
6533 using DiagState = DiagnosticsEngine::DiagState;
6544 auto ReadDiagState = [&](
const DiagState &BasedOn,
6545 bool IncludeNonPragmaStates) {
6546 unsigned BackrefID =
Record[Idx++];
6548 return DiagStates[BackrefID - 1];
6551 Diag.DiagStates.push_back(BasedOn);
6552 DiagState *NewState = &
Diag.DiagStates.back();
6553 DiagStates.push_back(NewState);
6554 unsigned Size =
Record[Idx++];
6555 assert(Idx + Size * 2 <=
Record.size() &&
6556 "Invalid data, not enough diag/map pairs");
6558 unsigned DiagID =
Record[Idx++];
6561 if (!NewMapping.
isPragma() && !IncludeNonPragmaStates)
6574 Mapping = NewMapping;
6580 DiagState *FirstState;
6585 FirstState =
Diag.DiagStatesByLoc.FirstDiagState;
6586 DiagStates.push_back(FirstState);
6590 "Invalid data, unexpected backref in initial state");
6592 assert(Idx <
Record.size() &&
6593 "Invalid data, not enough state change pairs in initial state");
6598 unsigned Flags =
Record[Idx++];
6600 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
6601 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
6602 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
6603 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
6604 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
6606 FirstState = ReadDiagState(Initial,
true);
6614 .StateTransitions.push_back({FirstState, 0});
6619 FirstState = ReadDiagState(*
Diag.DiagStatesByLoc.CurDiagState,
false);
6623 unsigned NumLocations =
Record[Idx++];
6624 while (NumLocations--) {
6625 assert(Idx <
Record.size() &&
6626 "Invalid data, missing pragma diagnostic states");
6628 assert(FID.
isValid() &&
"invalid FileID for transition");
6629 unsigned Transitions =
Record[Idx++];
6635 auto &F =
Diag.DiagStatesByLoc.Files[FID];
6636 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
6637 for (
unsigned I = 0; I != Transitions; ++I) {
6638 unsigned Offset =
Record[Idx++];
6639 auto *State = ReadDiagState(*FirstState,
false);
6640 F.StateTransitions.push_back({State, Offset});
6645 assert(Idx <
Record.size() &&
6646 "Invalid data, missing final pragma diagnostic state");
6648 auto *CurState = ReadDiagState(*FirstState,
false);
6651 Diag.DiagStatesByLoc.CurDiagState = CurState;
6652 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
6657 auto &
T =
Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
6659 T.push_back({CurState, 0});
6661 T[0].State = CurState;
6670ASTReader::RecordLocation ASTReader::TypeCursorForIndex(
unsigned Index) {
6671 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
6672 assert(I != GlobalTypeMap.end() &&
"Corrupted global type map");
6680#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
6681 case TYPE_##CODE_ID: return Type::CLASS_ID;
6682#include "clang/Serialization/TypeBitCodes.def"
6684 return std::nullopt;
6694QualType ASTReader::readTypeRecord(
unsigned Index) {
6695 assert(ContextObj &&
"reading type with no AST context");
6697 RecordLocation
Loc = TypeCursorForIndex(Index);
6698 BitstreamCursor &DeclsCursor =
Loc.F->DeclsCursor;
6704 ReadingKindTracker ReadingKind(Read_Type, *
this);
6707 Deserializing AType(
this);
6709 if (llvm::Error Err = DeclsCursor.JumpToBit(
Loc.Offset)) {
6710 Error(std::move(Err));
6715 Error(RawCode.takeError());
6722 Error(Code.takeError());
6733 Error(
"Unexpected code for type");
6738 return TypeReader.read(*maybeClass);
6766 : Reader(Reader),
Seq(
Seq) {}
6771#define ABSTRACT_TYPELOC(CLASS, PARENT)
6772#define TYPELOC(CLASS, PARENT) \
6773 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6774#include "clang/AST/TypeLocNodes.def"
6840 if (Reader.readBool())
6847 VisitArrayTypeLoc(TL);
6851 VisitArrayTypeLoc(TL);
6855 VisitArrayTypeLoc(TL);
6858void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6860 VisitArrayTypeLoc(TL);
6863void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6871void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6880void TypeLocReader::VisitDependentVectorTypeLoc(
6896void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
6910 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i) {
6916 VisitFunctionTypeLoc(TL);
6920 VisitFunctionTypeLoc(TL);
6927void TypeLocReader::VisitUsingTypeLoc(
UsingTypeLoc TL) {
6965 auto NNS = readNestedNameSpecifierLoc();
6966 auto TemplateKWLoc = readSourceLocation();
6967 auto ConceptNameLoc = readDeclarationNameInfo();
6968 auto FoundDecl = readDeclAs<NamedDecl>();
6969 auto NamedConcept = readDeclAs<ConceptDecl>();
6971 getContext(), NNS, TemplateKWLoc, ConceptNameLoc, FoundDecl, NamedConcept,
6972 (readBool() ? readASTTemplateArgumentListInfo() :
nullptr));
6976void TypeLocReader::VisitAutoTypeLoc(
AutoTypeLoc TL) {
6978 if (Reader.readBool())
6980 if (Reader.readBool())
6984void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6993void TypeLocReader::VisitEnumTypeLoc(
EnumTypeLoc TL) {
7013void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
7018void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
7023void TypeLocReader::VisitTemplateSpecializationTypeLoc(
7029 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
7031 Reader.readTemplateArgumentLocInfo(
7035void TypeLocReader::VisitParenTypeLoc(
ParenTypeLoc TL) {
7055void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
7063 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I)
7065 Reader.readTemplateArgumentLocInfo(
7109void TypeLocReader::VisitPipeTypeLoc(
PipeTypeLoc TL) {
7116void TypeLocReader::VisitDependentBitIntTypeLoc(
7133 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
7139 assert(ContextObj &&
"reading type with no AST context");
7150 llvm_unreachable(
"Invalid predefined type");
7339#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7340 case PREDEF_TYPE_##Id##_ID: \
7341 T = Context.SingletonId; \
7343#include "clang/Basic/OpenCLImageTypes.def"
7344#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7345 case PREDEF_TYPE_##Id##_ID: \
7346 T = Context.Id##Ty; \
7348#include "clang/Basic/OpenCLExtensionTypes.def"
7388#define SVE_TYPE(Name, Id, SingletonId) \
7389 case PREDEF_TYPE_##Id##_ID: \
7390 T = Context.SingletonId; \
7392#include "clang/Basic/AArch64SVEACLETypes.def"
7393#define PPC_VECTOR_TYPE(Name, Id, Size) \
7394 case PREDEF_TYPE_##Id##_ID: \
7395 T = Context.Id##Ty; \
7397#include "clang/Basic/PPCTypes.def"
7398#define RVV_TYPE(Name, Id, SingletonId) \
7399 case PREDEF_TYPE_##Id##_ID: \
7400 T = Context.SingletonId; \
7402#include "clang/Basic/RISCVVTypes.def"
7403#define WASM_TYPE(Name, Id, SingletonId) \
7404 case PREDEF_TYPE_##Id##_ID: \
7405 T = Context.SingletonId; \
7407#include "clang/Basic/WebAssemblyReferenceTypes.def"
7410 assert(!
T.isNull() &&
"Unknown predefined type");
7411 return T.withFastQualifiers(FastQuals);
7415 assert(Index < TypesLoaded.size() &&
"Type index out-of-range");
7416 if (TypesLoaded[Index].isNull()) {
7417 TypesLoaded[Index] = readTypeRecord(Index);
7418 if (TypesLoaded[Index].isNull())
7421 TypesLoaded[Index]->setFromAST();
7422 if (DeserializationListener)
7424 TypesLoaded[Index]);
7427 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7431 return GetType(getGlobalTypeID(F, LocalID));
7443 ReadModuleOffsetMap(F);
7447 assert(I != F.
TypeRemap.
end() &&
"Invalid index into type index remap");
7449 unsigned GlobalIndex = LocalIndex + I->second;
7459 return readTypeSourceInfo();
7462 readNestedNameSpecifierLoc();
7472 TemplateNameLoc, EllipsisLoc);
7483 llvm_unreachable(
"unexpected template argument loc");
7498 Result.setLAngleLoc(readSourceLocation());
7499 Result.setRAngleLoc(readSourceLocation());
7500 unsigned NumArgsAsWritten = readInt();
7501 for (
unsigned i = 0; i != NumArgsAsWritten; ++i)
7502 Result.addArgument(readTemplateArgumentLoc());
7508 readTemplateArgumentListInfo(
Result);
7515 if (NumCurrentElementsDeserializing) {
7520 PendingIncompleteDeclChains.push_back(
const_cast<Decl*
>(D));
7525 assert(isa<TranslationUnitDecl>(D) &&
"Not a TU?");
7536 if (isa<TranslationUnitDecl, NamespaceDecl, RecordDecl, EnumDecl>(DC)) {
7538 if (!getContext().getLangOpts().
CPlusPlus &&
7539 isa<TranslationUnitDecl>(DC)) {
7543 auto *II = Name.getAsIdentifierInfo();
7544 assert(II &&
"non-identifier name in C?");
7545 if (II->isOutOfDate())
7546 updateOutOfDateIdentifier(*II);
7552 auto *DC = cast<DeclContext>(DCDecl);
7554 FindExternalLexicalDecls(
7560 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7561 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7562 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7563 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7564 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
7565 if (
auto *Template = FD->getPrimaryTemplate())
7566 Template->LoadLazySpecializations();
7572 RecordLocation
Loc = getLocalBitOffset(Offset);
7573 BitstreamCursor &Cursor =
Loc.F->DeclsCursor;
7575 if (llvm::Error Err = Cursor.JumpToBit(
Loc.Offset)) {
7576 Error(std::move(Err));
7579 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7584 Error(MaybeCode.takeError());
7587 unsigned Code = MaybeCode.get();
7591 if (!MaybeRecCode) {
7592 Error(MaybeRecCode.takeError());
7596 Error(
"malformed AST file: missing C++ ctor initializers");
7600 return Record.readCXXCtorInitializers();
7604 assert(ContextObj &&
"reading base specifiers with no AST context");
7607 RecordLocation
Loc = getLocalBitOffset(Offset);
7608 BitstreamCursor &Cursor =
Loc.F->DeclsCursor;
7610 if (llvm::Error Err = Cursor.JumpToBit(
Loc.Offset)) {
7611 Error(std::move(Err));
7614 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7619 Error(MaybeCode.takeError());
7622 unsigned Code = MaybeCode.get();
7626 if (!MaybeRecCode) {
7627 Error(MaybeCode.takeError());
7630 unsigned RecCode = MaybeRecCode.get();
7633 Error(
"malformed AST file: missing C++ base specifiers");
7637 unsigned NumBases =
Record.readInt();
7640 for (
unsigned I = 0; I != NumBases; ++I)
7641 Bases[I] =
Record.readCXXBaseSpecifier();
7652 ReadModuleOffsetMap(F);
7656 assert(I != F.
DeclRemap.
end() &&
"Invalid index into decl index remap");
7675 assert(I != GlobalDeclMap.end() &&
"Corrupted global declaration map");
7685 if (Index > DeclsLoaded.size()) {
7686 Error(
"declaration ID out-of-range for AST file");
7690 if (
Decl *D = DeclsLoaded[Index])
7691 return D->getLocation();
7694 DeclCursorForID(ID,
Loc);
7754 llvm_unreachable(
"PredefinedDeclIDs unknown enum value");
7758 assert(ContextObj &&
"reading decl with no AST context");
7766 Merged.push_back(ID);
7773 if (Index >= DeclsLoaded.size()) {
7774 assert(0 &&
"declaration ID out-of-range for AST file");
7775 Error(
"declaration ID out-of-range for AST file");
7779 return DeclsLoaded[Index];
7784 return GetExistingDecl(ID);
7788 if (Index >= DeclsLoaded.size()) {
7789 assert(0 &&
"declaration ID out-of-range for AST file");
7790 Error(
"declaration ID out-of-range for AST file");
7794 if (!DeclsLoaded[Index]) {
7796 if (DeserializationListener)
7797 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7800 return DeclsLoaded[Index];
7810 assert(I != GlobalDeclMap.end() &&
"Corrupted global declaration map");
7813 llvm::DenseMap<ModuleFile *, DeclID>::iterator Pos =
7823 if (Idx >=
Record.size()) {
7824 Error(
"Corrupted AST file");
7838 ClearSwitchCaseIDs();
7841 RecordLocation
Loc = getLocalBitOffset(Offset);
7842 if (llvm::Error Err =
Loc.F->DeclsCursor.JumpToBit(
Loc.Offset)) {
7843 Error(std::move(Err));
7846 assert(NumCurrentElementsDeserializing == 0 &&
7847 "should not be called while already deserializing");
7849 return ReadStmtFromStream(*
Loc.F);
7858 assert(LexicalDecls.size() % 2 == 0 &&
"expected an even number of entries");
7859 for (
int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7861 if (!IsKindWeWant(K))
7864 auto ID = (
DeclID) + LexicalDecls[I + 1];
7869 if (PredefsVisited[ID])
7872 PredefsVisited[ID] =
true;
7876 assert(D->getKind() == K &&
"wrong kind for lexical decl");
7883 if (isa<TranslationUnitDecl>(DC)) {
7884 for (
const auto &Lexical : TULexicalDecls)
7885 Visit(Lexical.first, Lexical.second);
7887 auto I = LexicalDecls.find(DC);
7888 if (I != LexicalDecls.end())
7889 Visit(I->second.first, I->second.second);
7892 ++NumLexicalDeclContextsRead;
7929 unsigned Offset,
unsigned Length,
7933 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(
File);
7934 if (I == FileDeclIDs.end())
7937 FileDeclsInfo &DInfo = I->second;
7938 if (DInfo.Decls.empty())
7942 BeginLoc =
SM.getLocForStartOfFile(
File).getLocWithOffset(Offset);
7945 DeclIDComp DIDComp(*
this, *DInfo.Mod);
7947 llvm::lower_bound(DInfo.Decls, BeginLoc, DIDComp);
7948 if (BeginIt != DInfo.Decls.begin())
7954 while (BeginIt != DInfo.Decls.begin() &&
7955 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7956 ->isTopLevelDeclInObjCContainer())
7960 llvm::upper_bound(DInfo.Decls, EndLoc, DIDComp);
7961 if (EndIt != DInfo.Decls.end())
7965 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7972 "DeclContext has no visible decls in storage");
7976 auto It = Lookups.find(DC);
7977 if (It == Lookups.end())
7987 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7988 if (ND->
getDeclName() == Name && Found.insert(ND).second)
7989 Decls.push_back(ND);
7992 ++NumVisibleDeclContextsRead;
7993 SetExternalVisibleDeclsForName(DC, Name, Decls);
7994 return !Decls.empty();
8001 auto It = Lookups.find(DC);
8002 assert(It != Lookups.end() &&
8003 "have external visible storage but no lookup tables");
8008 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
8012 ++NumVisibleDeclContextsRead;
8014 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
8015 SetExternalVisibleDeclsForName(DC, I->first, I->second);
8017 const_cast<DeclContext *
>(DC)->setHasExternalVisibleStorage(
false);
8022 auto I = Lookups.find(Primary);
8023 return I == Lookups.end() ? nullptr : &I->second;
8032 assert(ImplD && Consumer);
8034 for (
auto *I : ImplD->
methods())
8040void ASTReader::PassInterestingDeclToConsumer(
Decl *D) {
8048 this->Consumer = Consumer;
8051 PassInterestingDeclsToConsumer();
8053 if (DeserializationListener)
8054 DeserializationListener->ReaderInitialized(
this);
8058 std::fprintf(stderr,
"*** AST File Statistics:\n");
8060 unsigned NumTypesLoaded =
8061 TypesLoaded.size() - llvm::count(TypesLoaded.materialized(),
QualType());
8062 unsigned NumDeclsLoaded =
8063 DeclsLoaded.size() -
8064 llvm::count(DeclsLoaded.materialized(), (
Decl *)
nullptr);
8065 unsigned NumIdentifiersLoaded =
8066 IdentifiersLoaded.size() -
8068 unsigned NumMacrosLoaded =
8069 MacrosLoaded.size() - llvm::count(MacrosLoaded, (
MacroInfo *)
nullptr);
8070 unsigned NumSelectorsLoaded =
8071 SelectorsLoaded.size() - llvm::count(SelectorsLoaded,
Selector());
8073 if (
unsigned TotalNumSLocEntries = getTotalNumSLocs())
8074 std::fprintf(stderr,
" %u/%u source location entries read (%f%%)\n",
8075 NumSLocEntriesRead, TotalNumSLocEntries,
8076 ((
float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
8077 if (!TypesLoaded.empty())
8078 std::fprintf(stderr,
" %u/%u types read (%f%%)\n",
8079 NumTypesLoaded, (
unsigned)TypesLoaded.size(),
8080 ((
float)NumTypesLoaded/TypesLoaded.size() * 100));
8081 if (!DeclsLoaded.empty())
8082 std::fprintf(stderr,
" %u/%u declarations read (%f%%)\n",
8083 NumDeclsLoaded, (
unsigned)DeclsLoaded.size(),
8084 ((
float)NumDeclsLoaded/DeclsLoaded.size() * 100));
8085 if (!IdentifiersLoaded.empty())
8086 std::fprintf(stderr,
" %u/%u identifiers read (%f%%)\n",
8087 NumIdentifiersLoaded, (
unsigned)IdentifiersLoaded.size(),
8088 ((
float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
8089 if (!MacrosLoaded.empty())
8090 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8091 NumMacrosLoaded, (
unsigned)MacrosLoaded.size(),
8092 ((
float)NumMacrosLoaded/MacrosLoaded.size() * 100));
8093 if (!SelectorsLoaded.empty())
8094 std::fprintf(stderr,
" %u/%u selectors read (%f%%)\n",
8095 NumSelectorsLoaded, (
unsigned)SelectorsLoaded.size(),
8096 ((
float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
8097 if (TotalNumStatements)
8098 std::fprintf(stderr,
" %u/%u statements read (%f%%)\n",
8099 NumStatementsRead, TotalNumStatements,
8100 ((
float)NumStatementsRead/TotalNumStatements * 100));
8102 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8103 NumMacrosRead, TotalNumMacros,
8104 ((
float)NumMacrosRead/TotalNumMacros * 100));
8105 if (TotalLexicalDeclContexts)
8106 std::fprintf(stderr,
" %u/%u lexical declcontexts read (%f%%)\n",
8107 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
8108 ((
float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
8110 if (TotalVisibleDeclContexts)
8111 std::fprintf(stderr,
" %u/%u visible declcontexts read (%f%%)\n",
8112 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
8113 ((
float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
8115 if (TotalNumMethodPoolEntries)
8116 std::fprintf(stderr,
" %u/%u method pool entries read (%f%%)\n",
8117 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
8118 ((
float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
8120 if (NumMethodPoolLookups)
8121 std::fprintf(stderr,
" %u/%u method pool lookups succeeded (%f%%)\n",
8122 NumMethodPoolHits, NumMethodPoolLookups,
8123 ((
float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
8124 if (NumMethodPoolTableLookups)
8125 std::fprintf(stderr,
" %u/%u method pool table lookups succeeded (%f%%)\n",
8126 NumMethodPoolTableHits, NumMethodPoolTableLookups,
8127 ((
float)NumMethodPoolTableHits/NumMethodPoolTableLookups
8129 if (NumIdentifierLookupHits)
8130 std::fprintf(stderr,
8131 " %u / %u identifier table lookups succeeded (%f%%)\n",
8132 NumIdentifierLookupHits, NumIdentifierLookups,
8133 (
double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
8136 std::fprintf(stderr,
"\n");
8137 GlobalIndex->printStats();
8140 std::fprintf(stderr,
"\n");
8142 std::fprintf(stderr,
"\n");
8145template<
typename Key,
typename ModuleFile,
unsigned InitialCapacity>
8146LLVM_DUMP_METHOD
static void
8149 InitialCapacity> &Map) {
8150 if (Map.begin() == Map.end())
8155 llvm::errs() << Name <<
":\n";
8156 for (
typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
8159 if constexpr (std::is_integral_v<Key>)
8162 ID = I->first.get();
8163 llvm::errs() <<
" " << ID <<
" -> " << I->second->FileName <<
"\n";
8168 llvm::errs() <<
"*** PCH/ModuleFile Remappings:\n";
8170 dumpModuleIDMap(
"Global source location entry map", GlobalSLocEntryMap);
8178 GlobalPreprocessedEntityMap);
8180 llvm::errs() <<
"\n*** PCH/Modules Loaded:";
8189 if (llvm::MemoryBuffer *buf = I.Buffer) {
8190 size_t bytes = buf->getBufferSize();
8191 switch (buf->getBufferKind()) {
8192 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
8195 case llvm::MemoryBuffer::MemoryBuffer_MMap:
8210 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
8213 PreloadedDeclIDs.clear();
8216 if (!FPPragmaOptions.empty()) {
8217 assert(FPPragmaOptions.size() == 1 &&
"Wrong number of FP_PRAGMA_OPTIONS");
8220 SemaObj->CurFPFeatures =
8224 SemaObj->OpenCLFeatures = OpenCLExtensions;
8230 assert(SemaObj &&
"no Sema to update");
8234 if (!SemaDeclRefs.empty()) {
8235 assert(SemaDeclRefs.size() % 3 == 0);
8236 for (
unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
8237 if (!SemaObj->StdNamespace)
8238 SemaObj->StdNamespace = SemaDeclRefs[I].get();
8239 if (!SemaObj->StdBadAlloc)
8240 SemaObj->StdBadAlloc = SemaDeclRefs[I + 1].get();
8241 if (!SemaObj->StdAlignValT)
8242 SemaObj->StdAlignValT = SemaDeclRefs[I + 2].get();
8244 SemaDeclRefs.clear();
8249 if(OptimizeOffPragmaLocation.isValid())
8250 SemaObj->ActOnPragmaOptimize(
false, OptimizeOffPragmaLocation);
8251 if (PragmaMSStructState != -1)
8253 if (PointersToMembersPragmaLocation.isValid()) {
8254 SemaObj->ActOnPragmaMSPointersToMembers(
8256 PragmaMSPointersToMembersState,
8257 PointersToMembersPragmaLocation);
8259 SemaObj->CUDA().ForceHostDeviceDepth = ForceHostDeviceDepth;
8261 if (PragmaAlignPackCurrentValue) {
8265 bool DropFirst =
false;
8266 if (!PragmaAlignPackStack.empty() &&
8267 PragmaAlignPackStack.front().Location.isInvalid()) {
8268 assert(PragmaAlignPackStack.front().Value ==
8269 SemaObj->AlignPackStack.DefaultValue &&
8270 "Expected a default alignment value");
8271 SemaObj->AlignPackStack.Stack.emplace_back(
8272 PragmaAlignPackStack.front().SlotLabel,
8273 SemaObj->AlignPackStack.CurrentValue,
8274 SemaObj->AlignPackStack.CurrentPragmaLocation,
8275 PragmaAlignPackStack.front().PushLocation);
8278 for (
const auto &Entry :
8279 llvm::ArrayRef(PragmaAlignPackStack).drop_front(DropFirst ? 1 : 0)) {
8280 SemaObj->AlignPackStack.Stack.emplace_back(
8281 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8283 if (PragmaAlignPackCurrentLocation.isInvalid()) {
8284 assert(*PragmaAlignPackCurrentValue ==
8285 SemaObj->AlignPackStack.DefaultValue &&
8286 "Expected a default align and pack value");
8289 SemaObj->AlignPackStack.CurrentValue = *PragmaAlignPackCurrentValue;
8290 SemaObj->AlignPackStack.CurrentPragmaLocation =
8291 PragmaAlignPackCurrentLocation;
8294 if (FpPragmaCurrentValue) {
8298 bool DropFirst =
false;
8299 if (!FpPragmaStack.empty() && FpPragmaStack.front().Location.isInvalid()) {
8300 assert(FpPragmaStack.front().Value ==
8301 SemaObj->FpPragmaStack.DefaultValue &&
8302 "Expected a default pragma float_control value");
8303 SemaObj->FpPragmaStack.Stack.emplace_back(
8304 FpPragmaStack.front().SlotLabel, SemaObj->FpPragmaStack.CurrentValue,
8305 SemaObj->FpPragmaStack.CurrentPragmaLocation,
8306 FpPragmaStack.front().PushLocation);
8309 for (
const auto &Entry :
8311 SemaObj->FpPragmaStack.Stack.emplace_back(
8312 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8313 if (FpPragmaCurrentLocation.isInvalid()) {
8314 assert(*FpPragmaCurrentValue == SemaObj->FpPragmaStack.DefaultValue &&
8315 "Expected a default pragma float_control value");
8318 SemaObj->FpPragmaStack.CurrentValue = *FpPragmaCurrentValue;
8319 SemaObj->FpPragmaStack.CurrentPragmaLocation = FpPragmaCurrentLocation;
8324 for (
auto &Import : PendingImportedModulesSema) {
8325 if (Import.ImportLoc.isInvalid())
8327 if (
Module *Imported = getSubmodule(Import.ID)) {
8328 SemaObj->makeModuleVisible(Imported, Import.ImportLoc);
8331 PendingImportedModulesSema.clear();
8338 IdentifierLookupVisitor Visitor(Name, 0,
8339 NumIdentifierLookups,
8340 NumIdentifierLookupHits);
8346 if (PP.getLangOpts().CPlusPlus) {
8347 for (
auto *F : ModuleMgr.pch_modules())
8355 if (!loadGlobalIndex()) {
8356 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
8361 ModuleMgr.visit(Visitor, HitsPtr);
8365 markIdentifierUpToDate(II);
8383 ASTIdentifierLookupTable::key_iterator Current;
8387 ASTIdentifierLookupTable::key_iterator End;
8394 bool SkipModules =
false);
8396 StringRef Next()
override;
8403 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8407 while (Current == End) {
8419 Current = IdTable->key_begin();
8420 End = IdTable->key_end();
8425 StringRef
Result = *Current;
8434 std::unique_ptr<IdentifierIterator> Current;
8435 std::unique_ptr<IdentifierIterator> Queued;
8438 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator>
First,
8439 std::unique_ptr<IdentifierIterator> Second)
8440 : Current(
std::move(
First)), Queued(
std::move(Second)) {}
8442 StringRef Next()
override {
8446 StringRef result = Current->Next();
8447 if (!result.empty())
8452 std::swap(Current, Queued);
8461 std::unique_ptr<IdentifierIterator> ReaderIter(
8463 std::unique_ptr<IdentifierIterator> ModulesIter(
8464 GlobalIndex->createIdentifierIterator());
8465 return new ChainedIdentifierIterator(std::move(ReaderIter),
8466 std::move(ModulesIter));
8473namespace serialization {
8478 unsigned PriorGeneration;
8479 unsigned InstanceBits = 0;
8480 unsigned FactoryBits = 0;
8481 bool InstanceHasMoreThanOneDecl =
false;
8482 bool FactoryHasMoreThanOneDecl =
false;
8488 unsigned PriorGeneration)
8489 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8499 ++Reader.NumMethodPoolTableLookups;
8502 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8503 if (Pos == PoolTable->end())
8506 ++Reader.NumMethodPoolTableHits;
8507 ++Reader.NumSelectorsRead;
8511 ++Reader.NumMethodPoolEntriesRead;
8513 if (Reader.DeserializationListener)
8519 InstanceMethods.append(
Data.Instance.rbegin(),
Data.Instance.rend());
8520 FactoryMethods.append(
Data.Factory.rbegin(),
Data.Factory.rend());
8521 InstanceBits =
Data.InstanceBits;
8522 FactoryBits =
Data.FactoryBits;
8523 InstanceHasMoreThanOneDecl =
Data.InstanceHasMoreThanOneDecl;
8524 FactoryHasMoreThanOneDecl =
Data.FactoryHasMoreThanOneDecl;
8530 return InstanceMethods;
8535 return FactoryMethods;
8542 return InstanceHasMoreThanOneDecl;
8560 unsigned &Generation = SelectorGeneration[Sel];
8561 unsigned PriorGeneration = Generation;
8563 SelectorOutOfDate[Sel] =
false;
8566 ++NumMethodPoolLookups;
8568 ModuleMgr.
visit(Visitor);
8574 ++NumMethodPoolHits;
8599 if (SelectorOutOfDate[Sel])
8607 for (
unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8609 = dyn_cast_or_null<NamespaceDecl>(
GetDecl(KnownNamespaces[I])))
8610 Namespaces.push_back(Namespace);
8615 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8616 for (
unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8617 UndefinedButUsedDecl &
U = UndefinedButUsed[Idx++];
8620 Undefined.insert(std::make_pair(D,
Loc));
8622 UndefinedButUsed.clear();
8628 for (
unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8631 uint64_t Count = DelayedDeleteExprs[Idx++];
8632 for (uint64_t
C = 0;
C < Count; ++
C) {
8635 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8636 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8643 for (
unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8644 VarDecl *Var = dyn_cast_or_null<VarDecl>(
GetDecl(TentativeDefinitions[I]));
8646 TentativeDefs.push_back(Var);
8648 TentativeDefinitions.clear();
8653 for (
unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8655 = dyn_cast_or_null<DeclaratorDecl>(
GetDecl(UnusedFileScopedDecls[I]));
8659 UnusedFileScopedDecls.clear();
8664 for (
unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8666 = dyn_cast_or_null<CXXConstructorDecl>(
GetDecl(DelegatingCtorDecls[I]));
8670 DelegatingCtorDecls.clear();
8674 for (
unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8676 = dyn_cast_or_null<TypedefNameDecl>(
GetDecl(ExtVectorDecls[I]));
8680 ExtVectorDecls.clear();
8685 for (
unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8688 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8692 UnusedLocalTypedefNameCandidates.clear();
8697 for (
auto I : DeclsToCheckForDeferredDiags) {
8698 auto *D = dyn_cast_or_null<Decl>(
GetDecl(I));
8702 DeclsToCheckForDeferredDiags.clear();
8707 if (ReferencedSelectorsData.empty())
8712 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8714 while (I < DataSize) {
8718 Sels.push_back(std::make_pair(Sel, SelLoc));
8720 ReferencedSelectorsData.clear();
8725 if (WeakUndeclaredIdentifiers.empty())
8728 for (
unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; ) {
8736 WeakIDs.push_back(std::make_pair(WeakId, WI));
8738 WeakUndeclaredIdentifiers.clear();
8742 for (
unsigned Idx = 0, N = VTableUses.size(); Idx < N; ) {
8744 VTableUse &TableInfo = VTableUses[Idx++];
8745 VT.
Record = dyn_cast_or_null<CXXRecordDecl>(
GetDecl(TableInfo.ID));
8748 VTables.push_back(VT);
8756 for (
unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8757 PendingInstantiation &Inst = PendingInstantiations[Idx++];
8761 Pending.push_back(std::make_pair(D,
Loc));
8763 PendingInstantiations.clear();
8767 llvm::MapVector<
const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8769 for (
auto &LPT : LateParsedTemplates) {
8772 for (
unsigned Idx = 0, N = LateParsed.size(); Idx < N;
8777 auto LT = std::make_unique<LateParsedTemplate>();
8782 assert(F &&
"No module");
8784 unsigned TokN = LateParsed[Idx++];
8785 LT->Toks.reserve(TokN);
8786 for (
unsigned T = 0;
T < TokN; ++
T)
8787 LT->Toks.push_back(
ReadToken(*F, LateParsed, Idx));
8789 LPTMap.insert(std::make_pair(FD, std::move(
LT)));
8793 LateParsedTemplates.clear();
8800 LambdaDeclarationsForMerging.insert(
8813 assert(ID &&
"Non-zero identifier ID required");
8814 assert(ID <= IdentifiersLoaded.size() &&
"identifier ID out of range");
8815 IdentifiersLoaded[ID - 1] = II;
8816 if (DeserializationListener)
8839 if (NumCurrentElementsDeserializing && !Decls) {
8840 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8844 for (
unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8857 Decls->push_back(D);
8864 pushExternalDeclIntoScope(D, II);
8872 if (IdentifiersLoaded.empty()) {
8873 Error(
"no identifier table in AST file");
8878 if (!IdentifiersLoaded[ID]) {
8880 assert(I != GlobalIdentifierMap.
end() &&
"Corrupted global identifier map");
8883 const unsigned char *
Data =
8890 IdentifiersLoaded[ID] = &II;
8892 if (DeserializationListener)
8896 return IdentifiersLoaded[ID];
8908 ReadModuleOffsetMap(M);
8913 &&
"Invalid index into identifier index remap");
8915 return LocalID + I->second;
8922 if (MacrosLoaded.empty()) {
8923 Error(
"no macro table in AST file");
8928 if (!MacrosLoaded[ID]) {
8931 assert(I != GlobalMacroMap.
end() &&
"Corrupted global macro map");
8937 if (DeserializationListener)
8942 return MacrosLoaded[ID];
8950 ReadModuleOffsetMap(M);
8954 assert(I != M.
MacroRemap.
end() &&
"Invalid index into macro index remap");
8956 return LocalID + I->second;
8965 ReadModuleOffsetMap(M);
8970 &&
"Invalid index into submodule index remap");
8972 return LocalID + I->second;
8977 assert(GlobalID == 0 &&
"Unhandled global submodule ID");
8981 if (GlobalID > SubmodulesLoaded.size()) {
8982 Error(
"submodule ID out of range in AST file");
8997 return I == GlobalSubmoduleMap.
end() ? nullptr : I->second;
9000 unsigned IndexFromEnd = ID >> 1;
9001 assert(IndexFromEnd &&
"got reference to unknown module file");
9018 auto I = llvm::find(PCHModules, M);
9019 assert(I != PCHModules.end() &&
"emitting reference to unknown file");
9020 return (I - PCHModules.end()) << 1;
9030 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
9035 llvm::sys::path::parent_path(MF.
FileName),
9038 return std::nullopt;
9042 auto I = DefinitionSource.find(FD);
9043 if (I == DefinitionSource.end())
9056 if (ID > SelectorsLoaded.size()) {
9057 Error(
"selector ID out of range in AST file");
9061 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() ==
nullptr) {
9064 assert(I != GlobalSelectorMap.
end() &&
"Corrupted global selector map");
9068 SelectorsLoaded[ID - 1] =
9070 if (DeserializationListener)
9071 DeserializationListener->
SelectorRead(ID, SelectorsLoaded[ID - 1]);
9074 return SelectorsLoaded[ID - 1];
9092 ReadModuleOffsetMap(M);
9097 &&
"Invalid index into selector index remap");
9099 return LocalID + I->second;
9104 switch (Name.getNameKind()) {
9130 NameInfo.
setName(readDeclarationName());
9142 unsigned NumTPLists =
readInt();
9147 for (
unsigned i = 0; i != NumTPLists; ++i)
9158 unsigned NumParams =
readInt();
9160 Params.reserve(NumParams);
9162 Params.push_back(readDeclAs<NamedDecl>());
9164 bool HasRequiresClause =
readBool();
9165 Expr *RequiresClause = HasRequiresClause ?
readExpr() :
nullptr;
9168 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
9169 return TemplateParams;
9174 bool Canonicalize) {
9175 unsigned NumTemplateArgs =
readInt();
9176 TemplArgs.reserve(NumTemplateArgs);
9177 while (NumTemplateArgs--)
9183 unsigned NumDecls =
readInt();
9185 while (NumDecls--) {
9197 bool inheritConstructors =
readBool();
9203 Result.setInheritConstructors(inheritConstructors);
9210 unsigned NumInitializers =
readInt();
9211 assert(NumInitializers &&
"wrote ctor initializers but have no inits");
9213 for (
unsigned i = 0; i != NumInitializers; ++i) {
9215 bool IsBaseVirtual =
false;
9231 Member = readDeclAs<FieldDecl>();
9235 IndirectMember = readDeclAs<IndirectFieldDecl>();
9246 BOMInit =
new (Context)
9248 RParenLoc, MemberOrEllipsisLoc);
9250 BOMInit =
new (Context)
9253 BOMInit =
new (Context)
9257 BOMInit =
new (Context)
9259 LParenLoc,
Init, RParenLoc);
9262 unsigned SourceOrder =
readInt();
9266 CtorInitializers[i] = BOMInit;
9269 return CtorInitializers;
9277 for (
unsigned I = 0; I != N; ++I) {
9278 auto Kind = readNestedNameSpecifierKind();
9310 Builder.Extend(Context,
9312 T->getTypeLoc(), ColonColonLoc);
9318 Builder.MakeGlobal(Context, ColonColonLoc);
9331 return Builder.getWithLocInContext(Context);
9342 const StringRef Blob) {
9343 unsigned Count =
Record[0];
9344 const char *Byte = Blob.data();
9345 llvm::BitVector Ret = llvm::BitVector(Count,
false);
9346 for (
unsigned I = 0; I < Count; ++Byte)
9347 for (
unsigned Bit = 0; Bit < 8 && I < Count; ++Bit, ++I)
9348 if (*Byte & (1 << Bit))
9360 unsigned Len =
Record[Idx++];
9376 if (!BaseDirectory.empty())
9383 unsigned Major =
Record[Idx++];
9384 unsigned Minor =
Record[Idx++];
9385 unsigned Subminor =
Record[Idx++];
9387 return VersionTuple(Major);
9389 return VersionTuple(Major, Minor - 1);
9390 return VersionTuple(Major, Minor - 1, Subminor - 1);
9401 return Diag(CurrentImportLoc, DiagID);
9417 assert((*CurrSwitchCaseStmts)[ID] ==
nullptr &&
9418 "Already have a SwitchCase with this ID");
9419 (*CurrSwitchCaseStmts)[ID] = SC;
9424 assert((*CurrSwitchCaseStmts)[ID] !=
nullptr &&
"No SwitchCase with this ID");
9425 return (*CurrSwitchCaseStmts)[ID];
9429 CurrSwitchCaseStmts->clear();
9434 std::vector<RawComment *> Comments;
9441 BitstreamCursor &Cursor = I->first;
9448 Cursor.advanceSkippingSubblocks(
9449 BitstreamCursor::AF_DontPopBlockAtEnd);
9451 Error(MaybeEntry.takeError());
9454 llvm::BitstreamEntry Entry = MaybeEntry.get();
9456 switch (Entry.Kind) {
9457 case llvm::BitstreamEntry::SubBlock:
9458 case llvm::BitstreamEntry::Error:
9459 Error(
"malformed block record in AST file");
9461 case llvm::BitstreamEntry::EndBlock:
9463 case llvm::BitstreamEntry::Record:
9471 if (!MaybeComment) {
9472 Error(MaybeComment.takeError());
9481 bool IsTrailingComment =
Record[Idx++];
9482 bool IsAlmostTrailingComment =
Record[Idx++];
9484 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9490 llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
9491 FileToOffsetToComment;
9495 std::pair<FileID, unsigned>
Loc =
9511 assert(NumUserInputs <= NumInputs);
9512 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9513 for (
unsigned I = 0; I < N; ++I) {
9514 bool IsSystem = I >= NumUserInputs;
9516 Visitor(IFI, IsSystem);
9521 bool IncludeSystem,
bool Complain,
9523 bool isSystem)> Visitor) {
9526 assert(NumUserInputs <= NumInputs);
9527 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9528 for (
unsigned I = 0; I < N; ++I) {
9529 bool IsSystem = I >= NumUserInputs;
9530 InputFile IF = getInputFile(MF, I+1, Complain);
9531 Visitor(IF, IsSystem);
9539 for (
unsigned I = 0; I < NumInputs; ++I) {
9542 if (
auto FE = getInputFile(MF, I + 1).getFile())
9547void ASTReader::finishPendingActions() {
9549 !PendingIdentifierInfos.empty() || !PendingDeducedFunctionTypes.empty() ||
9550 !PendingDeducedVarTypes.empty() || !PendingIncompleteDeclChains.empty() ||
9551 !PendingDeclChains.empty() || !PendingMacroIDs.empty() ||
9552 !PendingDeclContextInfos.empty() || !PendingUpdateRecords.empty() ||
9553 !PendingObjCExtensionIvarRedeclarations.empty()) {
9556 using TopLevelDeclsMap =
9557 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9558 TopLevelDeclsMap TopLevelDecls;
9560 while (!PendingIdentifierInfos.empty()) {
9563 std::move(PendingIdentifierInfos.back().second);
9564 PendingIdentifierInfos.pop_back();
9571 for (
unsigned I = 0; I != PendingDeducedFunctionTypes.size(); ++I) {
9572 auto *FD = PendingDeducedFunctionTypes[I].first;
9573 FD->setType(
GetType(PendingDeducedFunctionTypes[I].second));
9575 if (
auto *DT = FD->getReturnType()->getContainedDeducedType()) {
9578 if (DT->isDeduced()) {
9579 PendingDeducedTypeUpdates.insert(
9580 {FD->getCanonicalDecl(), FD->getReturnType()});
9587 PendingUndeducedFunctionDecls.push_back(FD);
9591 PendingDeducedFunctionTypes.clear();
9595 for (
unsigned I = 0; I != PendingDeducedVarTypes.size(); ++I) {
9596 auto *VD = PendingDeducedVarTypes[I].first;
9597 VD->setType(
GetType(PendingDeducedVarTypes[I].second));
9599 PendingDeducedVarTypes.clear();
9603 for (
unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9604 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9606 PendingIncompleteDeclChains.clear();
9609 for (
unsigned I = 0; I != PendingDeclChains.size(); ++I)
9610 loadPendingDeclChain(PendingDeclChains[I].first,
9611 PendingDeclChains[I].second);
9612 PendingDeclChains.clear();
9615 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9616 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9618 for (
unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9619 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9624 for (
unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9627 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9629 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9631 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9632 if (!Info.M->isModule())
9636 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9638 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9639 if (Info.M->isModule())
9643 PendingMacroIDs.clear();
9647 while (!PendingDeclContextInfos.empty()) {
9648 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9649 PendingDeclContextInfos.pop_front();
9652 Info.D->setDeclContextsImpl(SemaDC, LexicalDC,
getContext());
9656 while (!PendingUpdateRecords.empty()) {
9657 auto Update = PendingUpdateRecords.pop_back_val();
9658 ReadingKindTracker ReadingKind(Read_Decl, *
this);
9659 loadDeclUpdateRecords(
Update);
9662 while (!PendingObjCExtensionIvarRedeclarations.empty()) {
9663 auto ExtensionsPair = PendingObjCExtensionIvarRedeclarations.back().first;
9664 auto DuplicateIvars =
9665 PendingObjCExtensionIvarRedeclarations.back().second;
9668 ExtensionsPair.first->getASTContext(),
9669 ExtensionsPair.second->getASTContext(), NonEquivalentDecls,
9673 if (Ctx.IsEquivalent(ExtensionsPair.first, ExtensionsPair.second)) {
9675 for (
auto IvarPair : DuplicateIvars) {
9676 ObjCIvarDecl *Ivar = IvarPair.first, *PrevIvar = IvarPair.second;
9678 Ivar->setDeclContextsImpl(PrevIvar->getDeclContext(),
9684 ExtensionsPair.first->setInvalidDecl();
9685 ExtensionsPair.second->getClassInterface()
9687 ->setIvarList(
nullptr);
9689 for (
auto IvarPair : DuplicateIvars) {
9690 Diag(IvarPair.first->getLocation(),
9691 diag::err_duplicate_ivar_declaration)
9692 << IvarPair.first->getIdentifier();
9693 Diag(IvarPair.second->getLocation(), diag::note_previous_definition);
9696 PendingObjCExtensionIvarRedeclarations.pop_back();
9702 assert(PendingFakeDefinitionData.empty() &&
9703 "faked up a class definition but never saw the real one");
9709 for (
Decl *D : PendingDefinitions) {
9710 if (
TagDecl *TD = dyn_cast<TagDecl>(D)) {
9711 if (
const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9716 if (
auto RD = dyn_cast<CXXRecordDecl>(D)) {
9717 for (
auto *R = getMostRecentExistingDecl(RD); R;
9718 R = R->getPreviousDecl()) {
9720 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9721 "declaration thinks it's the definition but it isn't");
9722 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9729 if (
auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9734 for (
auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9735 cast<ObjCInterfaceDecl>(R)->Data =
ID->Data;
9740 if (
auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9741 for (
auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9742 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9747 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9748 for (
auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9749 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9751 PendingDefinitions.clear();
9757 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9758 PBEnd = PendingBodies.end();
9759 PB != PBEnd; ++PB) {
9760 if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9770 if (
auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9771 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9776 if (!
getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9782 if (!FD->isLateTemplateParsed() &&
9783 !NonConstDefn->isLateTemplateParsed() &&
9787 FD->getODRHash() != NonConstDefn->getODRHash()) {
9788 if (!isa<CXXMethodDecl>(FD)) {
9789 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9790 }
else if (FD->getLexicalParent()->isFileContext() &&
9791 NonConstDefn->getLexicalParent()->isFileContext()) {
9795 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9806 PendingBodies.clear();
9809 for (
auto [RD, MD] : PendingAddedClassMembers) {
9810 RD->addedMember(MD);
9812 PendingAddedClassMembers.clear();
9815 for (
auto *ND : PendingMergedDefinitionsToDeduplicate)
9817 PendingMergedDefinitionsToDeduplicate.clear();
9820void ASTReader::diagnoseOdrViolations() {
9821 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9822 PendingRecordOdrMergeFailures.empty() &&
9823 PendingFunctionOdrMergeFailures.empty() &&
9824 PendingEnumOdrMergeFailures.empty() &&
9825 PendingObjCInterfaceOdrMergeFailures.empty() &&
9826 PendingObjCProtocolOdrMergeFailures.empty())
9833 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9834 PendingOdrMergeFailures.clear();
9835 for (
auto &Merge : OdrMergeFailures) {
9836 Merge.first->buildLookup();
9837 Merge.first->decls_begin();
9838 Merge.first->bases_begin();
9839 Merge.first->vbases_begin();
9840 for (
auto &RecordPair : Merge.second) {
9841 auto *RD = RecordPair.first;
9849 auto RecordOdrMergeFailures = std::move(PendingRecordOdrMergeFailures);
9850 PendingRecordOdrMergeFailures.clear();
9851 for (
auto &Merge : RecordOdrMergeFailures) {
9852 Merge.first->decls_begin();
9853 for (
auto &D : Merge.second)
9858 auto ObjCInterfaceOdrMergeFailures =
9859 std::move(PendingObjCInterfaceOdrMergeFailures);
9860 PendingObjCInterfaceOdrMergeFailures.clear();
9861 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
9862 Merge.first->decls_begin();
9863 for (
auto &InterfacePair : Merge.second)
9864 InterfacePair.first->decls_begin();
9868 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9869 PendingFunctionOdrMergeFailures.clear();
9870 for (
auto &Merge : FunctionOdrMergeFailures) {
9871 Merge.first->buildLookup();
9872 Merge.first->decls_begin();
9873 Merge.first->getBody();
9874 for (
auto &FD : Merge.second) {
9882 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9883 PendingEnumOdrMergeFailures.clear();
9884 for (
auto &Merge : EnumOdrMergeFailures) {
9885 Merge.first->decls_begin();
9886 for (
auto &
Enum : Merge.second) {
9887 Enum->decls_begin();
9892 auto ObjCProtocolOdrMergeFailures =
9893 std::move(PendingObjCProtocolOdrMergeFailures);
9894 PendingObjCProtocolOdrMergeFailures.clear();
9895 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
9896 Merge.first->decls_begin();
9897 for (
auto &ProtocolPair : Merge.second)
9898 ProtocolPair.first->decls_begin();
9907 while (!PendingOdrMergeChecks.empty()) {
9908 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9922 for (
auto *RI : D->
redecls()) {
9923 if (RI->getLexicalDeclContext() == CanonDef) {
9938 for (
auto *CanonMember : CanonDef->
decls()) {
9939 if (CanonMember->getCanonicalDecl() == DCanon) {
9948 if (
auto *ND = dyn_cast<NamedDecl>(CanonMember))
9950 Candidates.push_back(ND);
9956 if (!isa<TagDecl>(D))
9961 Deserializing RecursionGuard(
this);
9963 std::string CanonDefModule =
9965 cast<Decl>(CanonDef));
9968 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9970 if (Candidates.empty())
9971 Diag(cast<Decl>(CanonDef)->getLocation(),
9972 diag::note_module_odr_violation_no_possible_decls) << D;
9974 for (
unsigned I = 0, N = Candidates.size(); I != N; ++I)
9975 Diag(Candidates[I]->getLocation(),
9976 diag::note_module_odr_violation_possible_decl)
9980 DiagnosedOdrMergeFailures.insert(CanonDef);
9984 if (OdrMergeFailures.empty() && RecordOdrMergeFailures.empty() &&
9985 FunctionOdrMergeFailures.empty() && EnumOdrMergeFailures.empty() &&
9986 ObjCInterfaceOdrMergeFailures.empty() &&
9987 ObjCProtocolOdrMergeFailures.empty())
9994 for (
auto &Merge : OdrMergeFailures) {
9997 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10000 bool Diagnosed =
false;
10002 for (
auto &RecordPair : Merge.second) {
10003 if (DiagsEmitter.diagnoseMismatch(FirstRecord, RecordPair.first,
10004 RecordPair.second)) {
10017 Diag(Merge.first->getLocation(),
10018 diag::err_module_odr_violation_different_instantiations)
10025 for (
auto &Merge : RecordOdrMergeFailures) {
10028 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10032 bool Diagnosed =
false;
10033 for (
auto *SecondRecord : Merge.second) {
10034 if (DiagsEmitter.diagnoseMismatch(FirstRecord, SecondRecord)) {
10040 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10044 for (
auto &Merge : FunctionOdrMergeFailures) {
10046 bool Diagnosed =
false;
10047 for (
auto &SecondFunction : Merge.second) {
10048 if (DiagsEmitter.diagnoseMismatch(FirstFunction, SecondFunction)) {
10054 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10058 for (
auto &Merge : EnumOdrMergeFailures) {
10061 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10064 EnumDecl *FirstEnum = Merge.first;
10065 bool Diagnosed =
false;
10066 for (
auto &SecondEnum : Merge.second) {
10067 if (DiagsEmitter.diagnoseMismatch(FirstEnum, SecondEnum)) {
10073 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10076 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
10079 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10082 bool Diagnosed =
false;
10084 for (
auto &InterfacePair : Merge.second) {
10085 if (DiagsEmitter.diagnoseMismatch(FirstID, InterfacePair.first,
10086 InterfacePair.second)) {
10092 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10095 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
10098 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10102 bool Diagnosed =
false;
10103 for (
auto &ProtocolPair : Merge.second) {
10104 if (DiagsEmitter.diagnoseMismatch(FirstProtocol, ProtocolPair.first,
10105 ProtocolPair.second)) {
10111 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10116 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
10117 ReadTimer->startTimer();
10121 assert(NumCurrentElementsDeserializing &&
10122 "FinishedDeserializing not paired with StartedDeserializing");
10123 if (NumCurrentElementsDeserializing == 1) {
10126 finishPendingActions();
10128 --NumCurrentElementsDeserializing;
10130 if (NumCurrentElementsDeserializing == 0) {
10136 while (!PendingExceptionSpecUpdates.empty() ||
10137 !PendingDeducedTypeUpdates.empty()) {
10138 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
10139 PendingExceptionSpecUpdates.clear();
10140 for (
auto Update : ESUpdates) {
10141 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10145 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(
Update.second));
10146 for (
auto *Redecl :
Update.second->redecls())
10150 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
10151 PendingDeducedTypeUpdates.clear();
10152 for (
auto Update : DTUpdates) {
10153 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10159 auto UDTUpdates = std::move(PendingUndeducedFunctionDecls);
10160 PendingUndeducedFunctionDecls.clear();
10164 (void)UndeducedFD->getMostRecentDecl();
10168 ReadTimer->stopTimer();
10170 diagnoseOdrViolations();
10175 PassInterestingDeclsToConsumer();
10182 auto It = PendingFakeLookupResults.find(II);
10183 if (It != PendingFakeLookupResults.end()) {
10184 for (
auto *ND : It->second)
10189 It->second.clear();
10195 }
else if (SemaObj->
TUScope) {
10207 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
10208 StringRef isysroot,
10210 bool AllowASTWithCompilerErrors,
10211 bool AllowConfigurationMismatch,
bool ValidateSystemInputs,
10212 bool ValidateASTInputFilesContent,
bool UseGlobalIndex,
10213 std::unique_ptr<llvm::Timer> ReadTimer)
10217 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
10218 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
10219 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
10220 PCHContainerRdr, PP.getHeaderSearchInfo()),
10221 DummyIdResolver(PP), ReadTimer(
std::move(ReadTimer)), isysroot(isysroot),
10222 DisableValidationKind(DisableValidationKind),
10223 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
10224 AllowConfigurationMismatch(AllowConfigurationMismatch),
10225 ValidateSystemInputs(ValidateSystemInputs),
10226 ValidateASTInputFilesContent(ValidateASTInputFilesContent),
10227 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
10230 for (
const auto &Ext : Extensions) {
10231 auto BlockName = Ext->getExtensionMetadata().BlockName;
10232 auto Known = ModuleFileExtensions.find(BlockName);
10233 if (Known != ModuleFileExtensions.end()) {
10234 Diags.
Report(diag::warn_duplicate_module_file_extension)
10239 ModuleFileExtensions.insert({BlockName, Ext});
10244 if (OwnsDeserializationListener)
10245 delete DeserializationListener;
10249 return SemaObj ? SemaObj->
IdResolver : DummyIdResolver;
10253 unsigned AbbrevID) {
10256 return Cursor.readRecord(AbbrevID,
Record);
10273#define GEN_CLANG_CLAUSE_CLASS
10274#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
10275#include "llvm/Frontend/OpenMP/OMP.inc"
10289 switch (llvm::omp::Clause(
Record.readInt())) {
10290 case llvm::omp::OMPC_if:
10293 case llvm::omp::OMPC_final:
10296 case llvm::omp::OMPC_num_threads:
10299 case llvm::omp::OMPC_safelen:
10302 case llvm::omp::OMPC_simdlen:
10305 case llvm::omp::OMPC_sizes: {
10306 unsigned NumSizes =
Record.readInt();
10310 case llvm::omp::OMPC_full:
10313 case llvm::omp::OMPC_partial:
10316 case llvm::omp::OMPC_allocator:
10319 case llvm::omp::OMPC_collapse:
10322 case llvm::omp::OMPC_default:
10325 case llvm::omp::OMPC_proc_bind:
10328 case llvm::omp::OMPC_schedule:
10331 case llvm::omp::OMPC_ordered:
10334 case llvm::omp::OMPC_nowait:
10337 case llvm::omp::OMPC_untied:
10340 case llvm::omp::OMPC_mergeable:
10343 case llvm::omp::OMPC_read:
10346 case llvm::omp::OMPC_write:
10349 case llvm::omp::OMPC_update:
10352 case llvm::omp::OMPC_capture:
10355 case llvm::omp::OMPC_compare:
10358 case llvm::omp::OMPC_fail:
10361 case llvm::omp::OMPC_seq_cst:
10364 case llvm::omp::OMPC_acq_rel:
10367 case llvm::omp::OMPC_acquire:
10370 case llvm::omp::OMPC_release:
10373 case llvm::omp::OMPC_relaxed:
10376 case llvm::omp::OMPC_weak:
10379 case llvm::omp::OMPC_threads:
10382 case llvm::omp::OMPC_simd:
10385 case llvm::omp::OMPC_nogroup:
10388 case llvm::omp::OMPC_unified_address:
10391 case llvm::omp::OMPC_unified_shared_memory:
10394 case llvm::omp::OMPC_reverse_offload:
10397 case llvm::omp::OMPC_dynamic_allocators:
10400 case llvm::omp::OMPC_atomic_default_mem_order:
10403 case llvm::omp::OMPC_at:
10406 case llvm::omp::OMPC_severity:
10409 case llvm::omp::OMPC_message:
10412 case llvm::omp::OMPC_private:
10415 case llvm::omp::OMPC_firstprivate:
10418 case llvm::omp::OMPC_lastprivate:
10421 case llvm::omp::OMPC_shared:
10424 case llvm::omp::OMPC_reduction: {
10425 unsigned N =
Record.readInt();
10430 case llvm::omp::OMPC_task_reduction:
10433 case llvm::omp::OMPC_in_reduction:
10436 case llvm::omp::OMPC_linear:
10439 case llvm::omp::OMPC_aligned:
10442 case llvm::omp::OMPC_copyin:
10445 case llvm::omp::OMPC_copyprivate:
10448 case llvm::omp::OMPC_flush:
10451 case llvm::omp::OMPC_depobj:
10454 case llvm::omp::OMPC_depend: {
10455 unsigned NumVars =
Record.readInt();
10456 unsigned NumLoops =
Record.readInt();
10460 case llvm::omp::OMPC_device:
10463 case llvm::omp::OMPC_map: {
10472 case llvm::omp::OMPC_num_teams:
10475 case llvm::omp::OMPC_thread_limit:
10478 case llvm::omp::OMPC_priority:
10481 case llvm::omp::OMPC_grainsize:
10484 case llvm::omp::OMPC_num_tasks:
10487 case llvm::omp::OMPC_hint:
10490 case llvm::omp::OMPC_dist_schedule:
10493 case llvm::omp::OMPC_defaultmap:
10496 case llvm::omp::OMPC_to: {
10505 case llvm::omp::OMPC_from: {
10514 case llvm::omp::OMPC_use_device_ptr: {
10523 case llvm::omp::OMPC_use_device_addr: {
10532 case llvm::omp::OMPC_is_device_ptr: {
10541 case llvm::omp::OMPC_has_device_addr: {
10550 case llvm::omp::OMPC_allocate:
10553 case llvm::omp::OMPC_nontemporal:
10556 case llvm::omp::OMPC_inclusive:
10559 case llvm::omp::OMPC_exclusive:
10562 case llvm::omp::OMPC_order:
10565 case llvm::omp::OMPC_init:
10568 case llvm::omp::OMPC_use:
10571 case llvm::omp::OMPC_destroy:
10574 case llvm::omp::OMPC_novariants:
10577 case llvm::omp::OMPC_nocontext:
10580 case llvm::omp::OMPC_detach:
10583 case llvm::omp::OMPC_uses_allocators:
10586 case llvm::omp::OMPC_affinity:
10589 case llvm::omp::OMPC_filter:
10592 case llvm::omp::OMPC_bind:
10595 case llvm::omp::OMPC_align:
10598 case llvm::omp::OMPC_ompx_dyn_cgroup_mem:
10601 case llvm::omp::OMPC_doacross: {
10602 unsigned NumVars =
Record.readInt();
10603 unsigned NumLoops =
Record.readInt();
10607 case llvm::omp::OMPC_ompx_attribute:
10610 case llvm::omp::OMPC_ompx_bare:
10613#define OMP_CLAUSE_NO_CLASS(Enum, Str) \
10614 case llvm::omp::Enum: \
10616#include "llvm/Frontend/OpenMP/OMPKinds.def"
10620 assert(
C &&
"Unknown OMPClause type");
10623 C->setLocStart(
Record.readSourceLocation());
10624 C->setLocEnd(
Record.readSourceLocation());
10630 C->setPreInitStmt(
Record.readSubStmt(),
10636 C->setPostUpdateExpr(
Record.readSubExpr());
10639void OMPClauseReader::VisitOMPIfClause(
OMPIfClause *
C) {
10642 C->setNameModifierLoc(
Record.readSourceLocation());
10643 C->setColonLoc(
Record.readSourceLocation());
10644 C->setCondition(
Record.readSubExpr());
10645 C->setLParenLoc(
Record.readSourceLocation());
10650 C->setCondition(
Record.readSubExpr());
10651 C->setLParenLoc(
Record.readSourceLocation());
10656 C->setNumThreads(
Record.readSubExpr());
10657 C->setLParenLoc(
Record.readSourceLocation());
10661 C->setSafelen(
Record.readSubExpr());
10662 C->setLParenLoc(
Record.readSourceLocation());
10666 C->setSimdlen(
Record.readSubExpr());
10667 C->setLParenLoc(
Record.readSourceLocation());
10671 for (
Expr *&E :
C->getSizesRefs())
10672 E =
Record.readSubExpr();
10673 C->setLParenLoc(
Record.readSourceLocation());
10679 C->setFactor(
Record.readSubExpr());
10680 C->setLParenLoc(
Record.readSourceLocation());
10684 C->setAllocator(
Record.readExpr());
10685 C->setLParenLoc(
Record.readSourceLocation());
10689 C->setNumForLoops(
Record.readSubExpr());
10690 C->setLParenLoc(
Record.readSourceLocation());
10694 C->setDefaultKind(
static_cast<llvm::omp::DefaultKind
>(
Record.readInt()));
10695 C->setLParenLoc(
Record.readSourceLocation());
10696 C->setDefaultKindKwLoc(
Record.readSourceLocation());
10700 C->setProcBindKind(
static_cast<llvm::omp::ProcBindKind
>(
Record.readInt()));
10701 C->setLParenLoc(
Record.readSourceLocation());
10702 C->setProcBindKindKwLoc(
Record.readSourceLocation());
10707 C->setScheduleKind(
10709 C->setFirstScheduleModifier(
10711 C->setSecondScheduleModifier(
10713 C->setChunkSize(
Record.readSubExpr());
10714 C->setLParenLoc(
Record.readSourceLocation());
10715 C->setFirstScheduleModifierLoc(
Record.readSourceLocation());
10716 C->setSecondScheduleModifierLoc(
Record.readSourceLocation());
10717 C->setScheduleKindLoc(
Record.readSourceLocation());
10718 C->setCommaLoc(
Record.readSourceLocation());
10722 C->setNumForLoops(
Record.readSubExpr());
10723 for (
unsigned I = 0, E =
C->NumberOfLoops; I < E; ++I)
10724 C->setLoopNumIterations(I,
Record.readSubExpr());
10725 for (
unsigned I = 0, E =
C->NumberOfLoops; I < E; ++I)
10726 C->setLoopCounter(I,
Record.readSubExpr());
10727 C->setLParenLoc(
Record.readSourceLocation());
10731 C->setEventHandler(
Record.readSubExpr());
10732 C->setLParenLoc(
Record.readSourceLocation());
10741void OMPClauseReader::VisitOMPReadClause(
OMPReadClause *) {}
10746 if (
C->isExtended()) {
10747 C->setLParenLoc(
Record.readSourceLocation());
10748 C->setArgumentLoc(
Record.readSourceLocation());
10760 C->setLParenLoc(
Record.readSourceLocation());
10762 C->setFailParameterLoc(FailParameterLoc);
10764 C->setFailParameter(CKind);
10777void OMPClauseReader::VisitOMPWeakClause(
OMPWeakClause *) {}
10781void OMPClauseReader::VisitOMPSIMDClause(
OMPSIMDClause *) {}
10786 unsigned NumVars =
C->varlist_size();
10788 Vars.reserve(NumVars);
10789 for (
unsigned I = 0; I != NumVars; ++I)
10790 Vars.push_back(
Record.readSubExpr());
10791 C->setVarRefs(Vars);
10792 C->setIsTarget(
Record.readBool());
10793 C->setIsTargetSync(
Record.readBool());
10794 C->setLParenLoc(
Record.readSourceLocation());
10795 C->setVarLoc(
Record.readSourceLocation());
10799 C->setInteropVar(
Record.readSubExpr());
10800 C->setLParenLoc(
Record.readSourceLocation());
10801 C->setVarLoc(
Record.readSourceLocation());
10805 C->setInteropVar(
Record.readSubExpr());
10806 C->setLParenLoc(
Record.readSourceLocation());
10807 C->setVarLoc(
Record.readSourceLocation());
10812 C->setCondition(
Record.readSubExpr());
10813 C->setLParenLoc(
Record.readSourceLocation());
10818 C->setCondition(
Record.readSubExpr());
10819 C->setLParenLoc(
Record.readSourceLocation());
10824void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
10833void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
10835 C->setAtomicDefaultMemOrderKind(
10837 C->setLParenLoc(
Record.readSourceLocation());
10838 C->setAtomicDefaultMemOrderKindKwLoc(
Record.readSourceLocation());
10841void OMPClauseReader::VisitOMPAtClause(
OMPAtClause *
C) {
10843 C->setLParenLoc(
Record.readSourceLocation());
10844 C->setAtKindKwLoc(
Record.readSourceLocation());
10849 C->setLParenLoc(
Record.readSourceLocation());
10850 C->setSeverityKindKwLoc(
Record.readSourceLocation());
10854 C->setMessageString(
Record.readSubExpr());
10855 C->setLParenLoc(
Record.readSourceLocation());
10859 C->setLParenLoc(
Record.readSourceLocation());
10860 unsigned NumVars =
C->varlist_size();
10862 Vars.reserve(NumVars);
10863 for (
unsigned i = 0; i != NumVars; ++i)
10864 Vars.push_back(
Record.readSubExpr());
10865 C->setVarRefs(Vars);
10867 for (
unsigned i = 0; i != NumVars; ++i)
10868 Vars.push_back(
Record.readSubExpr());
10869 C->setPrivateCopies(Vars);
10874 C->setLParenLoc(
Record.readSourceLocation());
10875 unsigned NumVars =
C->varlist_size();
10877 Vars.reserve(NumVars);
10878 for (
unsigned i = 0; i != NumVars; ++i)
10879 Vars.push_back(
Record.readSubExpr());
10880 C->setVarRefs(Vars);
10882 for (
unsigned i = 0; i != NumVars; ++i)
10883 Vars.push_back(
Record.readSubExpr());
10884 C->setPrivateCopies(Vars);
10886 for (
unsigned i = 0; i != NumVars; ++i)
10887 Vars.push_back(
Record.readSubExpr());
10893 C->setLParenLoc(
Record.readSourceLocation());
10895 C->setKindLoc(
Record.readSourceLocation());
10896 C->setColonLoc(
Record.readSourceLocation());
10897 unsigned NumVars =
C->varlist_size();
10899 Vars.reserve(NumVars);
10900 for (
unsigned i = 0; i != NumVars; ++i)
10901 Vars.push_back(
Record.readSubExpr());
10902 C->setVarRefs(Vars);
10904 for (
unsigned i = 0; i != NumVars; ++i)
10905 Vars.push_back(
Record.readSubExpr());
10906 C->setPrivateCopies(Vars);
10908 for (
unsigned i = 0; i != NumVars; ++i)
10909 Vars.push_back(
Record.readSubExpr());
10910 C->setSourceExprs(Vars);
10912 for (
unsigned i = 0; i != NumVars; ++i)
10913 Vars.push_back(
Record.readSubExpr());
10914 C->setDestinationExprs(Vars);
10916 for (
unsigned i = 0; i != NumVars; ++i)
10917 Vars.push_back(
Record.readSubExpr());
10918 C->setAssignmentOps(Vars);
10922 C->setLParenLoc(
Record.readSourceLocation());
10923 unsigned NumVars =
C->varlist_size();
10925 Vars.reserve(NumVars);
10926 for (
unsigned i = 0; i != NumVars; ++i)
10927 Vars.push_back(
Record.readSubExpr());
10928 C->setVarRefs(Vars);
10933 C->setLParenLoc(
Record.readSourceLocation());
10934 C->setModifierLoc(
Record.readSourceLocation());
10935 C->setColonLoc(
Record.readSourceLocation());
10938 C->setQualifierLoc(NNSL);
10939 C->setNameInfo(DNI);
10941 unsigned NumVars =
C->varlist_size();
10943 Vars.reserve(NumVars);
10944 for (
unsigned i = 0; i != NumVars; ++i)
10945 Vars.push_back(
Record.readSubExpr());
10946 C->setVarRefs(Vars);
10948 for (
unsigned i = 0; i != NumVars; ++i)
10949 Vars.push_back(
Record.readSubExpr());
10950 C->setPrivates(Vars);
10952 for (
unsigned i = 0; i != NumVars; ++i)
10953 Vars.push_back(
Record.readSubExpr());
10954 C->setLHSExprs(Vars);
10956 for (
unsigned i = 0; i != NumVars; ++i)
10957 Vars.push_back(
Record.readSubExpr());
10958 C->setRHSExprs(Vars);
10960 for (
unsigned i = 0; i != NumVars; ++i)
10961 Vars.push_back(
Record.readSubExpr());
10962 C->setReductionOps(Vars);
10963 if (
C->getModifier() == OMPC_REDUCTION_inscan) {
10965 for (
unsigned i = 0; i != NumVars; ++i)
10966 Vars.push_back(
Record.readSubExpr());
10967 C->setInscanCopyOps(Vars);
10969 for (
unsigned i = 0; i != NumVars; ++i)
10970 Vars.push_back(
Record.readSubExpr());
10971 C->setInscanCopyArrayTemps(Vars);
10973 for (
unsigned i = 0; i != NumVars; ++i)
10974 Vars.push_back(
Record.readSubExpr());
10975 C->setInscanCopyArrayElems(Vars);
10981 C->setLParenLoc(
Record.readSourceLocation());
10982 C->setColonLoc(
Record.readSourceLocation());
10985 C->setQualifierLoc(NNSL);
10986 C->setNameInfo(DNI);
10988 unsigned NumVars =
C->varlist_size();
10990 Vars.reserve(NumVars);
10991 for (
unsigned I = 0; I != NumVars; ++I)
10992 Vars.push_back(
Record.readSubExpr());
10993 C->setVarRefs(Vars);
10995 for (
unsigned I = 0; I != NumVars; ++I)
10996 Vars.push_back(
Record.readSubExpr());
10997 C->setPrivates(Vars);
10999 for (
unsigned I = 0; I != NumVars; ++I)
11000 Vars.push_back(
Record.readSubExpr());
11001 C->setLHSExprs(Vars);
11003 for (
unsigned I = 0; I != NumVars; ++I)
11004 Vars.push_back(
Record.readSubExpr());
11005 C->setRHSExprs(Vars);
11007 for (
unsigned I = 0; I != NumVars; ++I)
11008 Vars.push_back(
Record.readSubExpr());
11009 C->setReductionOps(Vars);
11014 C->setLParenLoc(
Record.readSourceLocation());
11015 C->setColonLoc(
Record.readSourceLocation());
11018 C->setQualifierLoc(NNSL);
11019 C->setNameInfo(DNI);
11021 unsigned NumVars =
C->varlist_size();
11023 Vars.reserve(NumVars);
11024 for (
unsigned I = 0; I != NumVars; ++I)
11025 Vars.push_back(
Record.readSubExpr());
11026 C->setVarRefs(Vars);
11028 for (
unsigned I = 0; I != NumVars; ++I)
11029 Vars.push_back(
Record.readSubExpr());
11030 C->setPrivates(Vars);
11032 for (
unsigned I = 0; I != NumVars; ++I)
11033 Vars.push_back(
Record.readSubExpr());
11034 C->setLHSExprs(Vars);
11036 for (
unsigned I = 0; I != NumVars; ++I)
11037 Vars.push_back(
Record.readSubExpr());
11038 C->setRHSExprs(Vars);
11040 for (
unsigned I = 0; I != NumVars; ++I)
11041 Vars.push_back(
Record.readSubExpr());
11042 C->setReductionOps(Vars);
11044 for (
unsigned I = 0; I != NumVars; ++I)
11045 Vars.push_back(
Record.readSubExpr());
11046 C->setTaskgroupDescriptors(Vars);
11051 C->setLParenLoc(
Record.readSourceLocation());
11052 C->setColonLoc(
Record.readSourceLocation());
11054 C->setModifierLoc(
Record.readSourceLocation());
11055 unsigned NumVars =
C->varlist_size();
11057 Vars.reserve(NumVars);
11058 for (
unsigned i = 0; i != NumVars; ++i)
11059 Vars.push_back(
Record.readSubExpr());
11060 C->setVarRefs(Vars);
11062 for (
unsigned i = 0; i != NumVars; ++i)
11063 Vars.push_back(
Record.readSubExpr());
11064 C->setPrivates(Vars);
11066 for (
unsigned i = 0; i != NumVars; ++i)
11067 Vars.push_back(
Record.readSubExpr());
11070 for (
unsigned i = 0; i != NumVars; ++i)
11071 Vars.push_back(
Record.readSubExpr());
11072 C->setUpdates(Vars);
11074 for (
unsigned i = 0; i != NumVars; ++i)
11075 Vars.push_back(
Record.readSubExpr());
11076 C->setFinals(Vars);
11077 C->setStep(
Record.readSubExpr());
11078 C->setCalcStep(
Record.readSubExpr());
11080 for (
unsigned I = 0; I != NumVars + 1; ++I)
11081 Vars.push_back(
Record.readSubExpr());
11082 C->setUsedExprs(Vars);
11086 C->setLParenLoc(
Record.readSourceLocation());
11087 C->setColonLoc(
Record.readSourceLocation());
11088 unsigned NumVars =
C->varlist_size();
11090 Vars.reserve(NumVars);
11091 for (
unsigned i = 0; i != NumVars; ++i)
11092 Vars.push_back(
Record.readSubExpr());
11093 C->setVarRefs(Vars);
11094 C->setAlignment(
Record.readSubExpr());
11098 C->setLParenLoc(
Record.readSourceLocation());
11099 unsigned NumVars =
C->varlist_size();
11101 Exprs.reserve(NumVars);
11102 for (
unsigned i = 0; i != NumVars; ++i)
11103 Exprs.push_back(
Record.readSubExpr());
11104 C->setVarRefs(Exprs);
11106 for (
unsigned i = 0; i != NumVars; ++i)
11107 Exprs.push_back(
Record.readSubExpr());
11108 C->setSourceExprs(Exprs);
11110 for (
unsigned i = 0; i != NumVars; ++i)
11111 Exprs.push_back(
Record.readSubExpr());
11112 C->setDestinationExprs(Exprs);
11114 for (
unsigned i = 0; i != NumVars; ++i)
11115 Exprs.push_back(
Record.readSubExpr());
11116 C->setAssignmentOps(Exprs);
11120 C->setLParenLoc(
Record.readSourceLocation());
11121 unsigned NumVars =
C->varlist_size();
11123 Exprs.reserve(NumVars);
11124 for (
unsigned i = 0; i != NumVars; ++i)
11125 Exprs.push_back(
Record.readSubExpr());
11126 C->setVarRefs(Exprs);
11128 for (
unsigned i = 0; i != NumVars; ++i)
11129 Exprs.push_back(
Record.readSubExpr());
11130 C->setSourceExprs(Exprs);
11132 for (
unsigned i = 0; i != NumVars; ++i)
11133 Exprs.push_back(
Record.readSubExpr());
11134 C->setDestinationExprs(Exprs);
11136 for (
unsigned i = 0; i != NumVars; ++i)
11137 Exprs.push_back(
Record.readSubExpr());
11138 C->setAssignmentOps(Exprs);
11142 C->setLParenLoc(
Record.readSourceLocation());
11143 unsigned NumVars =
C->varlist_size();
11145 Vars.reserve(NumVars);
11146 for (
unsigned i = 0; i != NumVars; ++i)
11147 Vars.push_back(
Record.readSubExpr());
11148 C->setVarRefs(Vars);
11152 C->setDepobj(
Record.readSubExpr());
11153 C->setLParenLoc(
Record.readSourceLocation());
11157 C->setLParenLoc(
Record.readSourceLocation());
11158 C->setModifier(
Record.readSubExpr());
11159 C->setDependencyKind(
11161 C->setDependencyLoc(
Record.readSourceLocation());
11162 C->setColonLoc(
Record.readSourceLocation());
11163 C->setOmpAllMemoryLoc(
Record.readSourceLocation());
11164 unsigned NumVars =
C->varlist_size();
11166 Vars.reserve(NumVars);
11167 for (
unsigned I = 0; I != NumVars; ++I)
11168 Vars.push_back(
Record.readSubExpr());
11169 C->setVarRefs(Vars);
11170 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
11171 C->setLoopData(I,
Record.readSubExpr());
11177 C->setDevice(
Record.readSubExpr());
11178 C->setModifierLoc(
Record.readSourceLocation());
11179 C->setLParenLoc(
Record.readSourceLocation());
11183 C->setLParenLoc(
Record.readSourceLocation());
11184 bool HasIteratorModifier =
false;
11186 C->setMapTypeModifier(
11188 C->setMapTypeModifierLoc(I,
Record.readSourceLocation());
11189 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
11190 HasIteratorModifier =
true;
11192 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11193 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11196 C->setMapLoc(
Record.readSourceLocation());
11197 C->setColonLoc(
Record.readSourceLocation());
11198 auto NumVars =
C->varlist_size();
11199 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11200 auto TotalLists =
C->getTotalComponentListNum();
11201 auto TotalComponents =
C->getTotalComponentsNum();
11204 Vars.reserve(NumVars);
11205 for (
unsigned i = 0; i != NumVars; ++i)
11206 Vars.push_back(
Record.readExpr());
11207 C->setVarRefs(Vars);
11210 UDMappers.reserve(NumVars);
11211 for (
unsigned I = 0; I < NumVars; ++I)
11212 UDMappers.push_back(
Record.readExpr());
11213 C->setUDMapperRefs(UDMappers);
11215 if (HasIteratorModifier)
11216 C->setIteratorModifier(
Record.readExpr());
11219 Decls.reserve(UniqueDecls);
11220 for (
unsigned i = 0; i < UniqueDecls; ++i)
11222 C->setUniqueDecls(Decls);
11225 ListsPerDecl.reserve(UniqueDecls);
11226 for (
unsigned i = 0; i < UniqueDecls; ++i)
11227 ListsPerDecl.push_back(
Record.readInt());
11228 C->setDeclNumLists(ListsPerDecl);
11231 ListSizes.reserve(TotalLists);
11232 for (
unsigned i = 0; i < TotalLists; ++i)
11233 ListSizes.push_back(
Record.readInt());
11234 C->setComponentListSizes(ListSizes);
11237 Components.reserve(TotalComponents);
11238 for (
unsigned i = 0; i < TotalComponents; ++i) {
11241 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11244 C->setComponents(Components, ListSizes);
11248 C->setLParenLoc(
Record.readSourceLocation());
11249 C->setColonLoc(
Record.readSourceLocation());
11250 C->setAllocator(
Record.readSubExpr());
11251 unsigned NumVars =
C->varlist_size();
11253 Vars.reserve(NumVars);
11254 for (
unsigned i = 0; i != NumVars; ++i)
11255 Vars.push_back(
Record.readSubExpr());
11256 C->setVarRefs(Vars);
11261 C->setNumTeams(
Record.readSubExpr());
11262 C->setLParenLoc(
Record.readSourceLocation());
11267 C->setThreadLimit(
Record.readSubExpr());
11268 C->setLParenLoc(
Record.readSourceLocation());
11273 C->setPriority(
Record.readSubExpr());
11274 C->setLParenLoc(
Record.readSourceLocation());
11280 C->setGrainsize(
Record.readSubExpr());
11281 C->setModifierLoc(
Record.readSourceLocation());
11282 C->setLParenLoc(
Record.readSourceLocation());
11288 C->setNumTasks(
Record.readSubExpr());
11289 C->setModifierLoc(
Record.readSourceLocation());
11290 C->setLParenLoc(
Record.readSourceLocation());
11294 C->setHint(
Record.readSubExpr());
11295 C->setLParenLoc(
Record.readSourceLocation());
11300 C->setDistScheduleKind(
11302 C->setChunkSize(
Record.readSubExpr());
11303 C->setLParenLoc(
Record.readSourceLocation());
11304 C->setDistScheduleKindLoc(
Record.readSourceLocation());
11305 C->setCommaLoc(
Record.readSourceLocation());
11309 C->setDefaultmapKind(
11311 C->setDefaultmapModifier(
11313 C->setLParenLoc(
Record.readSourceLocation());
11314 C->setDefaultmapModifierLoc(
Record.readSourceLocation());
11315 C->setDefaultmapKindLoc(
Record.readSourceLocation());
11318void OMPClauseReader::VisitOMPToClause(
OMPToClause *
C) {
11319 C->setLParenLoc(
Record.readSourceLocation());
11321 C->setMotionModifier(
11323 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11325 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11326 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11327 C->setColonLoc(
Record.readSourceLocation());
11328 auto NumVars =
C->varlist_size();
11329 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11330 auto TotalLists =
C->getTotalComponentListNum();
11331 auto TotalComponents =
C->getTotalComponentsNum();
11334 Vars.reserve(NumVars);
11335 for (
unsigned i = 0; i != NumVars; ++i)
11336 Vars.push_back(
Record.readSubExpr());
11337 C->setVarRefs(Vars);
11340 UDMappers.reserve(NumVars);
11341 for (
unsigned I = 0; I < NumVars; ++I)
11342 UDMappers.push_back(
Record.readSubExpr());
11343 C->setUDMapperRefs(UDMappers);
11346 Decls.reserve(UniqueDecls);
11347 for (
unsigned i = 0; i < UniqueDecls; ++i)
11349 C->setUniqueDecls(Decls);
11352 ListsPerDecl.reserve(UniqueDecls);
11353 for (
unsigned i = 0; i < UniqueDecls; ++i)
11354 ListsPerDecl.push_back(
Record.readInt());
11355 C->setDeclNumLists(ListsPerDecl);
11358 ListSizes.reserve(TotalLists);
11359 for (
unsigned i = 0; i < TotalLists; ++i)
11360 ListSizes.push_back(
Record.readInt());
11361 C->setComponentListSizes(ListSizes);
11364 Components.reserve(TotalComponents);
11365 for (
unsigned i = 0; i < TotalComponents; ++i) {
11366 Expr *AssociatedExprPr =
Record.readSubExpr();
11367 bool IsNonContiguous =
Record.readBool();
11369 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11371 C->setComponents(Components, ListSizes);
11375 C->setLParenLoc(
Record.readSourceLocation());
11377 C->setMotionModifier(
11379 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11381 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11382 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11383 C->setColonLoc(
Record.readSourceLocation());
11384 auto NumVars =
C->varlist_size();
11385 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11386 auto TotalLists =
C->getTotalComponentListNum();
11387 auto TotalComponents =
C->getTotalComponentsNum();
11390 Vars.reserve(NumVars);
11391 for (
unsigned i = 0; i != NumVars; ++i)
11392 Vars.push_back(
Record.readSubExpr());
11393 C->setVarRefs(Vars);
11396 UDMappers.reserve(NumVars);
11397 for (
unsigned I = 0; I < NumVars; ++I)
11398 UDMappers.push_back(
Record.readSubExpr());
11399 C->setUDMapperRefs(UDMappers);
11402 Decls.reserve(UniqueDecls);
11403 for (
unsigned i = 0; i < UniqueDecls; ++i)
11405 C->setUniqueDecls(Decls);
11408 ListsPerDecl.reserve(UniqueDecls);
11409 for (
unsigned i = 0; i < UniqueDecls; ++i)
11410 ListsPerDecl.push_back(
Record.readInt());
11411 C->setDeclNumLists(ListsPerDecl);
11414 ListSizes.reserve(TotalLists);
11415 for (
unsigned i = 0; i < TotalLists; ++i)
11416 ListSizes.push_back(
Record.readInt());
11417 C->setComponentListSizes(ListSizes);
11420 Components.reserve(TotalComponents);
11421 for (
unsigned i = 0; i < TotalComponents; ++i) {
11422 Expr *AssociatedExprPr =
Record.readSubExpr();
11423 bool IsNonContiguous =
Record.readBool();
11425 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11427 C->setComponents(Components, ListSizes);
11431 C->setLParenLoc(
Record.readSourceLocation());
11432 auto NumVars =
C->varlist_size();
11433 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11434 auto TotalLists =
C->getTotalComponentListNum();
11435 auto TotalComponents =
C->getTotalComponentsNum();
11438 Vars.reserve(NumVars);
11439 for (
unsigned i = 0; i != NumVars; ++i)
11440 Vars.push_back(
Record.readSubExpr());
11441 C->setVarRefs(Vars);
11443 for (
unsigned i = 0; i != NumVars; ++i)
11444 Vars.push_back(
Record.readSubExpr());
11445 C->setPrivateCopies(Vars);
11447 for (
unsigned i = 0; i != NumVars; ++i)
11448 Vars.push_back(
Record.readSubExpr());
11452 Decls.reserve(UniqueDecls);
11453 for (
unsigned i = 0; i < UniqueDecls; ++i)
11455 C->setUniqueDecls(Decls);
11458 ListsPerDecl.reserve(UniqueDecls);
11459 for (
unsigned i = 0; i < UniqueDecls; ++i)
11460 ListsPerDecl.push_back(
Record.readInt());
11461 C->setDeclNumLists(ListsPerDecl);
11464 ListSizes.reserve(TotalLists);
11465 for (
unsigned i = 0; i < TotalLists; ++i)
11466 ListSizes.push_back(
Record.readInt());
11467 C->setComponentListSizes(ListSizes);
11470 Components.reserve(TotalComponents);
11471 for (
unsigned i = 0; i < TotalComponents; ++i) {
11472 auto *AssociatedExprPr =
Record.readSubExpr();
11474 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11477 C->setComponents(Components, ListSizes);
11481 C->setLParenLoc(
Record.readSourceLocation());
11482 auto NumVars =
C->varlist_size();
11483 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11484 auto TotalLists =
C->getTotalComponentListNum();
11485 auto TotalComponents =
C->getTotalComponentsNum();
11488 Vars.reserve(NumVars);
11489 for (
unsigned i = 0; i != NumVars; ++i)
11490 Vars.push_back(
Record.readSubExpr());
11491 C->setVarRefs(Vars);
11494 Decls.reserve(UniqueDecls);
11495 for (
unsigned i = 0; i < UniqueDecls; ++i)
11497 C->setUniqueDecls(Decls);
11500 ListsPerDecl.reserve(UniqueDecls);
11501 for (
unsigned i = 0; i < UniqueDecls; ++i)
11502 ListsPerDecl.push_back(
Record.readInt());
11503 C->setDeclNumLists(ListsPerDecl);
11506 ListSizes.reserve(TotalLists);
11507 for (
unsigned i = 0; i < TotalLists; ++i)
11508 ListSizes.push_back(
Record.readInt());
11509 C->setComponentListSizes(ListSizes);
11512 Components.reserve(TotalComponents);
11513 for (
unsigned i = 0; i < TotalComponents; ++i) {
11514 Expr *AssociatedExpr =
Record.readSubExpr();
11516 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11519 C->setComponents(Components, ListSizes);
11523 C->setLParenLoc(
Record.readSourceLocation());
11524 auto NumVars =
C->varlist_size();
11525 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11526 auto TotalLists =
C->getTotalComponentListNum();
11527 auto TotalComponents =
C->getTotalComponentsNum();
11530 Vars.reserve(NumVars);
11531 for (
unsigned i = 0; i != NumVars; ++i)
11532 Vars.push_back(
Record.readSubExpr());
11533 C->setVarRefs(Vars);
11537 Decls.reserve(UniqueDecls);
11538 for (
unsigned i = 0; i < UniqueDecls; ++i)
11540 C->setUniqueDecls(Decls);
11543 ListsPerDecl.reserve(UniqueDecls);
11544 for (
unsigned i = 0; i < UniqueDecls; ++i)
11545 ListsPerDecl.push_back(
Record.readInt());
11546 C->setDeclNumLists(ListsPerDecl);
11549 ListSizes.reserve(TotalLists);
11550 for (
unsigned i = 0; i < TotalLists; ++i)
11551 ListSizes.push_back(
Record.readInt());
11552 C->setComponentListSizes(ListSizes);
11555 Components.reserve(TotalComponents);
11556 for (
unsigned i = 0; i < TotalComponents; ++i) {
11557 Expr *AssociatedExpr =
Record.readSubExpr();
11559 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11562 C->setComponents(Components, ListSizes);
11566 C->setLParenLoc(
Record.readSourceLocation());
11567 auto NumVars =
C->varlist_size();
11568 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11569 auto TotalLists =
C->getTotalComponentListNum();
11570 auto TotalComponents =
C->getTotalComponentsNum();
11573 Vars.reserve(NumVars);
11574 for (
unsigned I = 0; I != NumVars; ++I)
11575 Vars.push_back(
Record.readSubExpr());
11576 C->setVarRefs(Vars);
11580 Decls.reserve(UniqueDecls);
11581 for (
unsigned I = 0; I < UniqueDecls; ++I)
11583 C->setUniqueDecls(Decls);
11586 ListsPerDecl.reserve(UniqueDecls);
11587 for (
unsigned I = 0; I < UniqueDecls; ++I)
11588 ListsPerDecl.push_back(
Record.readInt());
11589 C->setDeclNumLists(ListsPerDecl);
11592 ListSizes.reserve(TotalLists);
11593 for (
unsigned i = 0; i < TotalLists; ++i)
11594 ListSizes.push_back(
Record.readInt());
11595 C->setComponentListSizes(ListSizes);
11598 Components.reserve(TotalComponents);
11599 for (
unsigned I = 0; I < TotalComponents; ++I) {
11600 Expr *AssociatedExpr =
Record.readSubExpr();
11602 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11605 C->setComponents(Components, ListSizes);
11609 C->setLParenLoc(
Record.readSourceLocation());
11610 unsigned NumVars =
C->varlist_size();
11612 Vars.reserve(NumVars);
11613 for (
unsigned i = 0; i != NumVars; ++i)
11614 Vars.push_back(
Record.readSubExpr());
11615 C->setVarRefs(Vars);
11617 Vars.reserve(NumVars);
11618 for (
unsigned i = 0; i != NumVars; ++i)
11619 Vars.push_back(
Record.readSubExpr());
11620 C->setPrivateRefs(Vars);
11624 C->setLParenLoc(
Record.readSourceLocation());
11625 unsigned NumVars =
C->varlist_size();
11627 Vars.reserve(NumVars);
11628 for (
unsigned i = 0; i != NumVars; ++i)
11629 Vars.push_back(
Record.readSubExpr());
11630 C->setVarRefs(Vars);
11634 C->setLParenLoc(
Record.readSourceLocation());
11635 unsigned NumVars =
C->varlist_size();
11637 Vars.reserve(NumVars);
11638 for (
unsigned i = 0; i != NumVars; ++i)
11639 Vars.push_back(
Record.readSubExpr());
11640 C->setVarRefs(Vars);
11644 C->setLParenLoc(
Record.readSourceLocation());
11645 unsigned NumOfAllocators =
C->getNumberOfAllocators();
11647 Data.reserve(NumOfAllocators);
11648 for (
unsigned I = 0; I != NumOfAllocators; ++I) {
11655 C->setAllocatorsData(
Data);
11659 C->setLParenLoc(
Record.readSourceLocation());
11660 C->setModifier(
Record.readSubExpr());
11661 C->setColonLoc(
Record.readSourceLocation());
11662 unsigned NumOfLocators =
C->varlist_size();
11664 Locators.reserve(NumOfLocators);
11665 for (
unsigned I = 0; I != NumOfLocators; ++I)
11666 Locators.push_back(
Record.readSubExpr());
11667 C->setVarRefs(Locators);
11673 C->setLParenLoc(
Record.readSourceLocation());
11674 C->setKindKwLoc(
Record.readSourceLocation());
11675 C->setModifierKwLoc(
Record.readSourceLocation());
11680 C->setThreadID(
Record.readSubExpr());
11681 C->setLParenLoc(
Record.readSourceLocation());
11686 C->setLParenLoc(
Record.readSourceLocation());
11687 C->setBindKindLoc(
Record.readSourceLocation());
11691 C->setAlignment(
Record.readExpr());
11692 C->setLParenLoc(
Record.readSourceLocation());
11697 C->setSize(
Record.readSubExpr());
11698 C->setLParenLoc(
Record.readSourceLocation());
11702 C->setLParenLoc(
Record.readSourceLocation());
11703 C->setDependenceType(
11705 C->setDependenceLoc(
Record.readSourceLocation());
11706 C->setColonLoc(
Record.readSourceLocation());
11707 unsigned NumVars =
C->varlist_size();
11709 Vars.reserve(NumVars);
11710 for (
unsigned I = 0; I != NumVars; ++I)
11711 Vars.push_back(
Record.readSubExpr());
11712 C->setVarRefs(Vars);
11713 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
11714 C->setLoopData(I,
Record.readSubExpr());
11719 Record.readAttributes(Attrs);
11720 C->setAttrs(Attrs);
11721 C->setLocStart(
Record.readSourceLocation());
11722 C->setLParenLoc(
Record.readSourceLocation());
11723 C->setLocEnd(
Record.readSourceLocation());
11732 Set.Kind = readEnum<llvm::omp::TraitSet>();
11735 Selector.Kind = readEnum<llvm::omp::TraitSelector>();
11736 Selector.ScoreOrCondition =
nullptr;
11738 Selector.ScoreOrCondition = readExprRef();
11741 Property.Kind = readEnum<llvm::omp::TraitProperty>();
11750 if (Reader->ReadingKind == ASTReader::Read_Stmt) {
11755 for (
unsigned I = 0, E =
Data->getNumClauses(); I < E; ++I)
11757 Data->setClauses(Clauses);
11758 if (
Data->hasAssociatedStmt())
11760 for (
unsigned I = 0, E =
Data->getNumChildren(); I < E; ++I)
11765 unsigned NumVars =
readInt();
11767 for (
unsigned I = 0; I < NumVars; ++I)
11773 unsigned NumExprs =
readInt();
11775 for (
unsigned I = 0; I < NumExprs; ++I)
11785 switch (ClauseKind) {
11806 unsigned NumClauses =
readInt();
11808 for (
unsigned I = 0; I < NumClauses; ++I)
11867 LParenLoc, VarList, EndLoc);
11876 LParenLoc, IsReadOnly, VarList, EndLoc);
11885 LParenLoc, IsZero, VarList, EndLoc);
11894 LParenLoc, IsZero, VarList, EndLoc);
11900 AsyncExpr, EndLoc);
11908 DevNumExpr, QueuesLoc, QueueIdExprs,
11915 unsigned NumArchs =
readInt();
11917 for (
unsigned I = 0; I < NumArchs; ++I) {
11920 Archs.emplace_back(Ident,
Loc);
11924 LParenLoc, Archs, EndLoc);
11950 llvm_unreachable(
"Clause serialization not yet implemented");
11952 llvm_unreachable(
"Invalid Clause Kind");
11957 for (
unsigned I = 0; I < Clauses.size(); ++I)
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
static unsigned moduleKindForDiagnostic(ModuleKind Kind)
static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, ASTConsumer *Consumer)
Under non-PCH compilation the consumer receives the objc methods before receiving the implementation,...
static bool checkModuleCachePath(llvm::vfs::FileSystem &VFS, StringRef SpecificModuleCachePath, StringRef ExistingModuleCachePath, DiagnosticsEngine *Diags, const LangOptions &LangOpts, const PreprocessorOptions &PPOpts)
Check that the specified and the existing module cache paths are equivalent.
static llvm::Error doesntStartWithASTFileMagic(BitstreamCursor &Stream)
Whether Stream doesn't start with the AST/PCH file magic number 'CPCH'.
static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags)
static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool IsSystem, bool SystemHeaderWarningsInModule, bool Complain)
static void updateModuleTimestamp(ModuleFile &MF)
static void collectMacroDefinitions(const PreprocessorOptions &PPOpts, MacroDefinitionsMap &Macros, SmallVectorImpl< StringRef > *MacroNames=nullptr)
Collect the macro definitions provided by the given preprocessor options.
static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts, const PreprocessorOptions &ExistingPPOpts, bool ReadMacros, DiagnosticsEngine *Diags, FileManager &FileMgr, std::string &SuggestedPredefines, const LangOptions &LangOpts, OptionValidation Validation=OptionValidateContradictions)
Check the preprocessor options deserialized from the control block against the preprocessor options i...
static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool Complain)
static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method)
Move the given method to the back of the global list of methods.
static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps)
static bool isInterestingIdentifier(ASTReader &Reader, const IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
static bool parseModuleFileExtensionMetadata(const SmallVectorImpl< uint64_t > &Record, StringRef Blob, ModuleFileExtensionMetadata &Metadata)
Parse a record and blob containing module file extension metadata.
static Module * getTopImportImplicitModule(ModuleManager &ModuleMgr, Preprocessor &PP)
Return the top import module if it is implicit, nullptr otherwise.
static Decl * getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID)
static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II)
static void addMethodsToPool(Sema &S, ArrayRef< ObjCMethodDecl * > Methods, ObjCMethodList &List)
Add the given set of methods to the method list.
static bool readBit(unsigned &Bits)
static std::optional< Type::TypeClass > getTypeClassForCode(TypeCode code)
static std::pair< unsigned, unsigned > readULEBKeyDataLength(const unsigned char *&P)
Read ULEB-encoded key length and data length.
static LLVM_DUMP_METHOD void dumpModuleIDMap(StringRef Name, const ContinuousRangeMap< Key, ModuleFile *, InitialCapacity > &Map)
@ OptionValidateStrictMatches
@ OptionValidateContradictions
static bool checkTargetOptions(const TargetOptions &TargetOpts, const TargetOptions &ExistingTargetOpts, DiagnosticsEngine *Diags, bool AllowCompatibleDifferences=true)
Compare the given set of target options against an existing set of target options.
#define CHECK_TARGET_OPT(Field, Name)
static bool checkLanguageOptions(const LangOptions &LangOpts, const LangOptions &ExistingLangOpts, DiagnosticsEngine *Diags, bool AllowCompatibleDifferences=true)
Compare the given set of language options against an existing set of language options.
static ASTFileSignature readASTFileSignature(StringRef PCH)
Reads and return the signature record from PCH's control block, or else returns 0.
static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID)
Given a cursor at the start of an AST file, scan ahead and drop the cursor into the start of the give...
static uint64_t readULEB(const unsigned char *&P)
static StringRef bytes(const std::vector< T, Allocator > &v)
Defines the Diagnostic-related interfaces.
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::FileManager interface and associated types.
Defines the clang::FileSystemOptions interface.
llvm::DenseSet< const void * > Visited
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
static const Decl * getCanonicalDecl(const Decl *D)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::FileType FileType
llvm::MachO::Record Record
Defines the clang::MacroInfo and clang::MacroDirective classes.
Defines the clang::Module class, which describes a module in the source code.
Defines types useful for describing an Objective-C runtime.
Defines some OpenACC-specific enums and functions.
This file defines OpenMP AST classes for clauses.
Defines some OpenMP-specific enums and functions.
Defines an enumeration for C++ overloaded operators.
Defines the clang::Preprocessor interface.
static std::string getName(const CallEvent &Call)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::SanitizerKind enum.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for Objective-C.
Defines the clang::SourceLocation class and associated facilities.
Defines implementation details of the clang::SourceManager class.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TargetOptions class.
Defines the clang::TokenKind enum and support functions.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
Defines version macros and version-related utility functions for Clang.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.
virtual void HandleInterestingDecl(DeclGroupRef D)
HandleInterestingDecl - Handle the specified interesting declaration.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
CanQualType ObjCBuiltinSelTy
TranslationUnitDecl * getTranslationUnitDecl() const
CanQualType ARCUnbridgedCastTy
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C 'Class' type.
TypedefDecl * getCFConstantStringDecl() const
CanQualType SatUnsignedFractTy
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
ExternCContextDecl * getExternCContextDecl() const
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined 'SEL' type in Objective-C.
CanQualType UnsignedShortAccumTy
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
QualType getAutoRRefDeductType() const
C++11 deduction pattern for 'auto &&' type.
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type.
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any.
CanQualType SatLongAccumTy
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
CanQualType OMPArrayShapingTy
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
CanQualType UnsignedLongFractTy
CanQualType OMPIteratorTy
RawCommentList Comments
All comments in this translation unit.
CanQualType SatShortFractTy
CanQualType SatUnsignedAccumTy
CanQualType ArraySectionTy
CanQualType ObjCBuiltinIdTy
RecordDecl * getCFConstantStringTagDecl() const
CanQualType UnsignedFractTy
CanQualType ObjCBuiltinClassTy
CanQualType UnresolvedTemplateTy
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
OMPTraitInfo & getNewOMPTraitInfo()
Return a new OMPTraitInfo object owned by this context.
CanQualType UnsignedLongTy
CanQualType UnsignedLongAccumTy
CanQualType BoundMemberTy
CanQualType SatUnsignedShortFractTy
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
CanQualType PseudoObjectTy
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
CanQualType OCLClkEventTy
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated,...
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
CanQualType SatUnsignedShortAccumTy
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
CanQualType UnsignedInt128Ty
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
CanQualType UnsignedCharTy
CanQualType UnsignedShortFractTy
void * Allocate(size_t Size, unsigned Align=8) const
CanQualType UnsignedIntTy
TagDecl * getMSGuidTagDecl() const
Retrieve the implicitly-predeclared 'struct _GUID' declaration.
CanQualType UnsignedLongLongTy
CanQualType OCLReserveIDTy
CanQualType UnsignedShortTy
CanQualType SatUnsignedLongFractTy
void setcudaConfigureCallDecl(FunctionDecl *FD)
DiagnosticsEngine & getDiagnostics() const
CanQualType SatLongFractTy
CanQualType SatShortAccumTy
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CanQualType IncompleteMatrixIdxTy
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
BuiltinTemplateDecl * getTypePackElementDecl() const
CanQualType SatUnsignedLongAccumTy
void deduplicateMergedDefinitonsFor(NamedDecl *ND)
Clean up the merged definition list.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
void setPrimaryMergedDecl(Decl *D, Decl *Primary)
CanQualType UnsignedAccumTy
void setCFConstantStringType(QualType T)
virtual void MacroRead(serialization::MacroID ID, MacroInfo *MI)
A macro was read from the AST file.
virtual void SelectorRead(serialization::SelectorID iD, Selector Sel)
A selector was read from the AST file.
virtual void IdentifierRead(serialization::IdentifierID ID, IdentifierInfo *II)
An identifier was deserialized from the AST file.
An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files...
ASTIdentifierIterator(const ASTReader &Reader, bool SkipModules=false)
StringRef Next() override
Retrieve the next string in the identifier table and advances the iterator for the following string.
Abstract interface for callback invocations by the ASTReader.
virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain)
Receives the header search options.
virtual void ReadModuleMapFile(StringRef ModuleMapPath)
virtual bool needsInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the target options.
virtual bool visitInputFile(StringRef Filename, bool isSystem, bool isOverridden, bool isExplicitModule)
if needsInputFileVisitation returns true, this is called for each non-system input file of the AST Fi...
virtual bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts, bool Complain)
Receives the header search paths.
virtual bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain)
Receives the file system options.
virtual ~ASTReaderListener()
virtual bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain)
Receives the diagnostic options.
virtual void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata)
Indicates that a particular module file extension has been read.
virtual bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the language options.
virtual void visitImport(StringRef ModuleName, StringRef Filename)
If needsImportVisitation returns true, this is called for each AST file imported by this AST file.
virtual void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind)
This is called for each AST file loaded.
virtual bool needsImportVisitation() const
Returns true if this ASTReaderListener wants to receive the imports of the AST file via visitImport,...
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
virtual void ReadCounter(const serialization::ModuleFile &M, unsigned Value)
Receives COUNTER value.
virtual void ReadModuleName(StringRef ModuleName)
virtual bool needsSystemInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines)
Receives the preprocessor options.
Reads an AST files chain containing the contents of a translation unit.
std::optional< bool > isPreprocessedEntityInFileID(unsigned Index, FileID FID) override
Optionally returns true or false if the preallocated preprocessed entity with index Index came from f...
PreprocessedEntity * ReadPreprocessedEntity(unsigned Index) override
Read a preallocated preprocessed entity from the external source.
void markIdentifierUpToDate(const IdentifierInfo *II)
Note that this identifier is up-to-date.
void visitTopLevelModuleMaps(serialization::ModuleFile &MF, llvm::function_ref< void(FileEntryRef)> Visitor)
Visit all the top-level module maps loaded when building the given module file.
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) const
Retrieve the global submodule ID given a module and its local ID number.
ExtKind hasExternalDefinitions(const Decl *D) override
IdentifierTable & getIdentifierTable()
Retrieve the identifier table associated with the preprocessor.
ModuleManager & getModuleManager()
Retrieve the module manager.
bool isDeclIDFromModule(GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
friend class ASTIdentifierIterator
bool ReadSLocEntry(int ID) override
Read the source location entry with index ID.
void RecordSwitchCaseID(SwitchCase *SC, unsigned ID)
Record that the given ID maps to the given switch-case statement.
DiagnosticBuilder Diag(unsigned DiagID) const
Report a diagnostic.
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
static std::string ReadString(const RecordDataImpl &Record, unsigned &Idx)
void ReadDeclsToCheckForDeferredDiags(llvm::SmallSetVector< Decl *, 4 > &Decls) override
Read the set of decls to be checked for deferred diags.
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
@ ARR_Missing
The client can handle an AST file that cannot load because it is missing.
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
@ ARR_OutOfDate
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
@ ARR_VersionMismatch
The client can handle an AST file that cannot load because it was built with a different version of C...
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 > > &Exprs) override
void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl * > &Decls) override
Get the decls that are contained in a file in the Offset/Length range.
SourceRange ReadSkippedRange(unsigned Index) override
Read a preallocated skipped range from the external source.
void dump()
Dump information about the AST reader to standard error.
serialization::IdentifierID getGlobalIdentifierID(ModuleFile &M, unsigned LocalID)
void AssignedLambdaNumbering(const CXXRecordDecl *Lambda) override
Notify the external source that a lambda was assigned a mangling number.
MacroInfo * ReadMacroRecord(ModuleFile &F, uint64_t Offset)
Reads the macro record located at the given offset.
SmallVector< std::pair< llvm::BitstreamCursor, serialization::ModuleFile * >, 8 > CommentsCursors
Cursors for comments blocks.
Selector getLocalSelector(ModuleFile &M, unsigned LocalID)
Retrieve a selector from the given module with its local ID number.
void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl * > &Decls) override
Read all of the declarations lexically stored in a declaration context.
std::optional< ASTSourceDescriptor > getSourceDescriptor(unsigned ID) override
Return a descriptor for the corresponding module.
const serialization::reader::DeclContextLookupTable * getLoadedLookupTables(DeclContext *Primary) const
Get the loaded lookup tables for Primary, if any.
void ClearSwitchCaseIDs()
SourceLocation ReadSourceLocation(ModuleFile &MF, RawLocEncoding Raw, LocSeq *Seq=nullptr) const
Read a source location from raw form.
void SetGloballyVisibleDecls(IdentifierInfo *II, const SmallVectorImpl< GlobalDeclID > &DeclIDs, SmallVectorImpl< Decl * > *Decls=nullptr)
Set the globally-visible declarations associated with the given identifier.
void SetIdentifierInfo(unsigned ID, IdentifierInfo *II)
bool loadGlobalIndex()
Attempts to load the global index.
void ReadComments() override
Loads comments ranges.
SourceManager & getSourceManager() const
SourceLocation getSourceLocationForDeclID(GlobalDeclID ID)
Returns the source location for the decl ID.
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind NameVisibility, SourceLocation ImportLoc)
Make the entities in the given module and any of its (non-explicit) submodules visible to name lookup...
void finalizeForWriting()
Finalizes the AST reader's state before writing an AST file to disk.
Sema * getSema()
Retrieve the semantic analysis object used to analyze the translation unit in which the precompiled h...
CXXCtorInitializer ** GetExternalCXXCtorInitializers(uint64_t Offset) override
Read the contents of a CXXCtorInitializer array.
void visitInputFileInfos(serialization::ModuleFile &MF, bool IncludeSystem, llvm::function_ref< void(const serialization::InputFileInfo &IFI, bool IsSystem)> Visitor)
Visit all the input file infos of the given module file.
void StartTranslationUnit(ASTConsumer *Consumer) override
Function that will be invoked when we begin parsing a new translation unit involving this external AS...
LocalDeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, GlobalDeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
void resolvePendingMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo)
bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) override
Finds all the visible declarations with a given name.
void ReadTentativeDefinitions(SmallVectorImpl< VarDecl * > &TentativeDefs) override
Read the set of tentative definitions known to the external Sema source.
Decl * GetExternalDecl(GlobalDeclID ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
llvm::Expected< SourceLocation::UIntTy > readSLocOffset(ModuleFile *F, unsigned Index)
Try to read the offset of the SLocEntry at the given index in the given module file.
void CompleteRedeclChain(const Decl *D) override
If any redeclarations of D have been imported since it was last checked, this digs out those redeclar...
static llvm::Error ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, unsigned BlockID, uint64_t *StartOfBlockOffset=nullptr)
ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the specified cursor.
serialization::PreprocessedEntityID getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const
Determine the global preprocessed entity ID that corresponds to the given local ID within the given m...
std::pair< unsigned, unsigned > findPreprocessedEntitiesInRange(SourceRange Range) override
Returns a pair of [Begin, End) indices of preallocated preprocessed entities that Range encompasses.
IdentifierInfo * get(StringRef Name) override
Retrieve the IdentifierInfo for the named identifier.
void visitInputFiles(serialization::ModuleFile &MF, bool IncludeSystem, bool Complain, llvm::function_ref< void(const serialization::InputFile &IF, bool isSystem)> Visitor)
Visit all the input files of the given module file.
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
llvm::iterator_range< ModuleDeclIterator > getModuleFileLevelDecls(ModuleFile &Mod)
GlobalDeclID ReadDeclID(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a declaration ID from the given position in a record in the given module.
Stmt * GetExternalDeclStmt(uint64_t Offset) override
Resolve the offset of a statement into a statement.
Selector GetExternalSelector(serialization::SelectorID ID) override
Resolve a selector ID into a selector.
unsigned getTotalNumSelectors() const
Returns the number of selectors found in the chain.
MacroInfo * getMacro(serialization::MacroID ID)
Retrieve the macro with the given ID.
void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined) override
Load the set of used but not defined functions or variables with internal linkage,...
void ReadDelegatingConstructors(SmallVectorImpl< CXXConstructorDecl * > &Decls) override
Read the set of delegating constructors known to the external Sema source.
QualType GetType(serialization::TypeID ID)
Resolve a type ID into a type, potentially building a new type.
void addPendingMacro(IdentifierInfo *II, ModuleFile *M, uint32_t MacroDirectivesOffset)
Add a macro to deserialize its macro directive history.
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx, LocSeq *Seq=nullptr)
Read a source range.
GlobalDeclID getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const
Map from a local declaration ID within a given module to a global declaration ID.
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WeakIDs) override
Read the set of weak, undeclared identifiers known to the external Sema source.
void completeVisibleDeclsMap(const DeclContext *DC) override
Load all external visible decls in the given DeclContext.
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
IdentifierResolver & getIdResolver()
Get the identifier resolver used for name lookup / updates in the translation unit scope.
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)
Read the control block for the named AST file.
void ReadExtVectorDecls(SmallVectorImpl< TypedefNameDecl * > &Decls) override
Read the set of ext_vector type declarations known to the external Sema source.
void ResolveImportedPath(ModuleFile &M, std::string &Filename)
If we are loading a relocatable PCH or module file, and the filename is not an absolute path,...
ModuleFile * getOwningModuleFile(const Decl *D)
Retrieve the module file that owns the given declaration, or NULL if the declaration is not from a mo...
SmallVector< GlobalDeclID, 16 > PreloadedDeclIDs
std::pair< SourceLocation, StringRef > getModuleImportLoc(int ID) override
Retrieve the module import location and module name for the given source manager entry ID.
void ReadUnusedFileScopedDecls(SmallVectorImpl< const DeclaratorDecl * > &Decls) override
Read the set of unused file-scope declarations known to the external Sema source.
void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation > > &Sels) override
Read the set of referenced selectors known to the external Sema source.
Selector DecodeSelector(serialization::SelectorID Idx)
ASTReadResult ReadAST(StringRef FileName, ModuleKind Type, SourceLocation ImportLoc, unsigned ClientLoadCapabilities, ModuleFile **NewLoadedModuleFile=nullptr)
Load the AST file designated by the given file name.
StringRef getOriginalSourceFile()
Retrieve the name of the original source file name for the primary module file.
std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx)
unsigned getModuleFileID(ModuleFile *M)
Get an ID for the given module file.
IdentifierInfo * DecodeIdentifierInfo(serialization::IdentifierID ID)
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons.
@ Success
The control block was read successfully.
@ ConfigurationMismatch
The AST file was written with a different language/target configuration.
@ OutOfDate
The AST file is out-of-date relative to its input files, and needs to be regenerated.
@ Failure
The AST file itself appears corrupted.
@ VersionMismatch
The AST file was written by a different version of Clang.
@ HadErrors
The AST file has errors.
@ Missing
The AST file was missing.
static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx)
Read a version tuple.
Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx)
Reads a token out of a record.
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
void ReadLateParsedTemplates(llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate > > &LPTMap) override
Read the set of late parsed template functions for this source.
IdentifierIterator * getIdentifiers() override
Retrieve an iterator into the set of all identifiers in all loaded AST files.
void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables) override
Read the set of used vtables known to the external Sema source.
bool isGlobalIndexUnavailable() const
Determine whether we tried to load the global index, but failed, e.g., because it is out-of-date or d...
uint32_t GetNumExternalSelectors() override
Returns the number of selectors known to the external AST source.
void updateOutOfDateSelector(Selector Sel) override
Load the contents of the global method pool for a given selector if necessary.
Decl * GetExistingDecl(GlobalDeclID ID)
Resolve a declaration ID into a declaration.
static llvm::BitVector ReadBitVector(const RecordData &Record, const StringRef Blob)
ModuleFile * getLocalModuleFile(ModuleFile &M, unsigned ID) const
Retrieve the module file with a given local ID within the specified ModuleFile.
void LoadSelector(Selector Sel)
Load a selector from disk, registering its ID if it exists.
IdentifierInfo * getLocalIdentifier(ModuleFile &M, unsigned LocalID)
void ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag)
void makeNamesVisible(const HiddenNames &Names, Module *Owner)
Make the names within this set of hidden names visible.
void UpdateSema()
Update the state of Sema after loading some additional modules.
Decl * GetDecl(GlobalDeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
Decl * GetLocalDecl(ModuleFile &F, LocalDeclID LocalID)
Reads a declaration with the given local ID in the given module.
ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache, ASTContext *Context, const PCHContainerReader &PCHContainerRdr, ArrayRef< std::shared_ptr< ModuleFileExtension > > Extensions, StringRef isysroot="", DisableValidationForModuleKind DisableValidationKind=DisableValidationForModuleKind::None, bool AllowASTWithCompilerErrors=false, bool AllowConfigurationMismatch=false, bool ValidateSystemInputs=false, bool ValidateASTInputFilesContent=false, bool UseGlobalIndex=true, std::unique_ptr< llvm::Timer > ReadTimer={})
Load the AST file and validate its contents against the given Preprocessor.
int getSLocEntryID(SourceLocation::UIntTy SLocOffset) override
Get the index ID for the loaded SourceLocation offset.
void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending) override
Read the set of pending instantiations known to the external Sema source.
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
CXXTemporary * ReadCXXTemporary(ModuleFile &F, const RecordData &Record, unsigned &Idx)
void ReadKnownNamespaces(SmallVectorImpl< NamespaceDecl * > &Namespaces) override
Load the set of namespaces that are known to the external source, which will be used during typo corr...
QualType getLocalType(ModuleFile &F, unsigned LocalID)
Resolve a local type ID within a given AST file into a type.
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
void PrintStats() override
Print some statistics about AST usage.
void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef)
Note that MergedDef is a redefinition of the canonical definition Def, so Def should be visible whene...
serialization::SelectorID getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const
Retrieve the global selector ID that corresponds to this the local selector ID in a given module.
void StartedDeserializing() override
Notify ASTReader that we started deserialization of a decl or type so until FinishedDeserializing is ...
void ReadMethodPool(Selector Sel) override
Load the contents of the global method pool for a given selector.
void InitializeContext()
Initializes the ASTContext.
CXXBaseSpecifier * GetExternalCXXBaseSpecifiers(uint64_t Offset) override
Resolve the offset of a set of C++ base specifiers in the decl stream into an array of specifiers.
FileManager & getFileManager() const
serialization::TypeID getGlobalTypeID(ModuleFile &F, unsigned LocalID) const
Map a local type ID within a given AST file into a global type ID.
static bool isAcceptableASTFile(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts, const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts, StringRef ExistingModuleCachePath, bool RequireStrictOptionMatches=false)
Determine whether the given AST file is acceptable to load into a translation unit with the given lan...
void FinishedDeserializing() override
Notify ASTReader that we finished the deserialization of a decl or type.
void updateOutOfDateIdentifier(const IdentifierInfo &II) override
Update an out-of-date identifier.
void ReadDefinedMacros() override
Read the set of macros defined by this external macro source.
HeaderFileInfo GetHeaderFileInfo(FileEntryRef FE) override
Read the header file information for the given file entry.
serialization::MacroID getGlobalMacroID(ModuleFile &M, unsigned LocalID)
Retrieve the global macro ID corresponding to the given local ID within the given module file.
An object for streaming information from a record.
bool readBool()
Read a boolean value, advancing Idx.
uint32_t readUInt32()
Read a 32-bit unsigned value; required to satisfy BasicReader.
llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem)
Read an arbitrary constant value, advancing Idx.
TemplateArgumentLoc readTemplateArgumentLoc()
Reads a TemplateArgumentLoc, advancing Idx.
void readTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Reads the location information for a type.
void readUnresolvedSet(LazyASTUnresolvedSet &Set)
Read a UnresolvedSet structure, advancing Idx.
void readTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, bool Canonicalize=false)
Read a template argument array, advancing Idx.
void readQualifierInfo(QualifierInfo &Info)
DeclarationNameLoc readDeclarationNameLoc(DeclarationName Name)
Read a declaration name, advancing Idx.
CXXBaseSpecifier readCXXBaseSpecifier()
Read a C++ base specifier, advancing Idx.
Expected< unsigned > readRecord(llvm::BitstreamCursor &Cursor, unsigned AbbrevID)
Reads a record with id AbbrevID from Cursor, resetting the internal state.
DeclarationNameInfo readDeclarationNameInfo()
IdentifierInfo * readIdentifier()
TemplateArgumentLocInfo readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind)
Reads a TemplateArgumentLocInfo appropriate for the given TemplateArgument kind, advancing Idx.
TemplateArgument readTemplateArgument(bool Canonicalize)
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
TypeSourceInfo * readTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
void readTemplateArgumentListInfo(TemplateArgumentListInfo &Result)
TypeCoupledDeclRefInfo readTypeCoupledDeclRefInfo()
void skipInts(unsigned N)
Skips the specified number of values.
GlobalDeclID readDeclID()
Reads a declaration ID from the given position in this record.
SourceRange readSourceRange(LocSeq *Seq=nullptr)
Read a source range, advancing Idx.
NestedNameSpecifierLoc readNestedNameSpecifierLoc()
Return a nested name specifier, advancing Idx.
ConceptReference * readConceptReference()
void readOMPChildren(OMPChildren *Data)
Read an OpenMP children, advancing Idx.
OMPClause * readOMPClause()
Read an OpenMP clause, advancing Idx.
void readOpenACCClauseList(MutableArrayRef< const OpenACCClause * > Clauses)
Read a list of OpenACC clauses into the passed SmallVector.
OMPTraitInfo * readOMPTraitInfo()
Read an OMPTraitInfo object, advancing Idx.
TemplateParameterList * readTemplateParameterList()
Read a template parameter list, advancing Idx.
OpenACCClause * readOpenACCClause()
Read an OpenACC clause, advancing Idx.
llvm::SmallVector< Expr * > readOpenACCVarList()
Read a list of Exprs used for a var-list.
CXXCtorInitializer ** readCXXCtorInitializers()
Read a CXXCtorInitializer array, advancing Idx.
Stmt * readStmt()
Reads a statement.
const ASTTemplateArgumentListInfo * readASTTemplateArgumentListInfo()
uint64_t readInt()
Returns the current value in this record, and advances to the next value.
Attr * readAttr()
Reads one attribute from the current stream position, advancing Idx.
Expr * readExpr()
Reads an expression.
SourceLocation readSourceLocation(LocSeq *Seq=nullptr)
Read a source location, advancing Idx.
llvm::SmallVector< Expr * > readOpenACCIntExprList()
Read a list of Exprs used for a int-expr-list.
Expr * readSubExpr()
Reads a sub-expression operand during statement reading.
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
Wrapper for source info for array parameter types.
Wrapper for source info for arrays.
void setLBracketLoc(SourceLocation Loc)
void setRBracketLoc(SourceLocation Loc)
void setSizeExpr(Expr *Size)
void setRParenLoc(SourceLocation Loc)
void setLParenLoc(SourceLocation Loc)
void setKWLoc(SourceLocation Loc)
Attr - This represents one attribute.
Type source information for an attributed type.
void setAttr(const Attr *A)
void setConceptReference(ConceptReference *CR)
void setRParenLoc(SourceLocation Loc)
Type source information for an btf_tag attributed type.
Wrapper for source info for block pointers.
void setCaretLoc(SourceLocation Loc)
Wrapper for source info for builtin types.
void setWrittenTypeSpec(TypeSpecifierType written)
bool needsExtraLocalData() const
void setModeAttr(bool written)
void setBuiltinLoc(SourceLocation Loc)
void setWrittenWidthSpec(TypeSpecifierWidth written)
void setWrittenSignSpec(TypeSpecifierSign written)
Represents a base class of a C++ class.
Represents a C++ constructor within a class.
Represents a C++ base or member initializer.
void setSourceOrder(int Pos)
Set the source order of this initializer.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
unsigned getLambdaIndexInContext() const
Retrieve the index of this lambda within the context declaration returned by getLambdaContextDecl().
Represents a C++ temporary.
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
bool visitInputFile(StringRef Filename, bool isSystem, bool isOverridden, bool isExplicitModule) override
if needsInputFileVisitation returns true, this is called for each non-system input file of the AST Fi...
bool ReadFullVersionInformation(StringRef FullVersion) override
Receives the full Clang version information.
bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain) override
Receives the file system options.
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
void ReadModuleMapFile(StringRef ModuleMapPath) override
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
void ReadModuleName(StringRef ModuleName) override
bool needsInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata) override
Indicates that a particular module file extension has been read.
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind) override
This is called for each AST file loaded.
bool needsSystemInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
A reference to a concept and its template args, as it appears in the code.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const TypeClass * getTypePtr() const
An object that helps properly build a continuous range map from a set of values.
A map from continuous integer ranges to some value, with a very specialized interface.
void insertOrReplace(const value_type &Val)
typename Representation::const_iterator const_iterator
typename Representation::iterator iterator
Wrapper for source info for pointers decayed from arrays and functions.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void setMustBuildLookupTable()
Mark that there are external lexical declarations that we need to include in our lookup table (and th...
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context.
bool isDeclInLexicalTraversal(const Decl *D) const
Determine whether the given declaration is stored in the list of declarations lexically within this c...
Decl - This represents one declaration (or definition), e.g.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
Kind
Lists the kind of concrete classes of Decl.
GlobalDeclID getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
SourceLocation getLocation() const
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
DeclarationNameLoc - Additional source/type location info for a declaration name.
static DeclarationNameLoc makeNamedTypeLoc(TypeSourceInfo *TInfo)
Construct location information for a constructor, destructor or conversion operator.
static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc)
Construct location information for a literal C++ operator.
static DeclarationNameLoc makeCXXOperatorNameLoc(SourceLocation BeginLoc, SourceLocation EndLoc)
Construct location information for a non-literal C++ operator.
The name of a declaration.
NameKind
The kind of the name stored in this DeclarationName.
@ CXXConversionFunctionName
Represents a ValueDecl that came out of a declarator.
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
void setTemplateNameLoc(SourceLocation Loc)
void setAttrNameLoc(SourceLocation loc)
void setAttrOperandParensRange(SourceRange range)
void setAttrExprOperand(Expr *e)
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
void setNameLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
unsigned getNumArgs() const
void setTemplateKeywordLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateNameLoc(SourceLocation Loc)
ArrayRef< TemplateArgument > template_arguments() const
void setNameLoc(SourceLocation Loc)
A little helper class used to produce diagnostics.
Carries a Clang diagnostic in an llvm::Error.
static llvm::Error create(SourceLocation Loc, PartialDiagnostic Diag)
Creates a new DiagnosticError that contains the given diagnostic at the given location.
PartialDiagnosticAt & getDiagnostic()
bool wasUpgradedFromWarning() const
Whether this mapping attempted to map the diagnostic to a warning, but was overruled because the diag...
bool isErrorOrFatal() const
void setSeverity(diag::Severity Value)
static DiagnosticMapping deserialize(unsigned Bits)
Deserialize a mapping.
void setUpgradedFromWarning(bool Value)
Options for controlling the compiler diagnostics engine.
std::vector< std::string > SystemHeaderWarningsModules
The list of -Wsystem-header-in-module=... options used to override whether -Wsystem-headers is enable...
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
bool getEnableAllWarnings() const
Level
The level of the diagnostic, after it has been through mapping.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
bool getSuppressSystemWarnings() const
bool getWarningsAsErrors() const
diag::Severity getExtensionHandlingBehavior() const
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
StringRef getName() const
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Wrapper for source info for enum types.
This represents one expression.
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap'ed memor...
uint32_t getGeneration() const
Get the current generation of this AST source.
Represents difference between two FPOptions values.
static FPOptionsOverride getFromOpaqueInt(storage_type I)
FPOptions applyOverrides(FPOptions Base)
static FPOptions getFromOpaqueInt(storage_type Value)
Represents a member of a struct/union/class.
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
time_t getModificationTime() const
StringRef getName() const
The name of this FileEntry.
Cached information about one file (either on disk or in the virtual file system).
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Implements support for file system lookup, file system caching, and directory search management.
llvm::vfs::FileSystem & getVirtualFileSystem() const
OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Get a FileEntryRef if it exists, without doing anything on error.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(FileEntryRef Entry, bool isVolatile=false, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
FileEntryRef getVirtualFileRef(StringRef Filename, off_t Size, time_t ModificationTime)
Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...
llvm::ErrorOr< const FileEntry * > getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
Keeps track of options that affect how file operations are performed.
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
Represents a function declaration or definition.
void setLazyBody(uint64_t Offset)
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
Wrapper for source info for functions.
unsigned getNumParams() const
void setLocalRangeBegin(SourceLocation L)
void setLParenLoc(SourceLocation Loc)
void setParam(unsigned i, ParmVarDecl *VD)
void setRParenLoc(SourceLocation Loc)
void setLocalRangeEnd(SourceLocation L)
void setExceptionSpecRange(SourceRange R)
static std::pair< GlobalModuleIndex *, llvm::Error > readIndex(llvm::StringRef Path)
Read a global index file for the given directory.
One of these records is kept for each identifier that is lexed.
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
bool isCPlusPlusOperatorKeyword() const
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
void setIsPoisoned(bool Value=true)
setIsPoisoned - Mark this identifier as poisoned.
bool isFromAST() const
Return true if the identifier in its current state was loaded from an AST file.
bool isPoisoned() const
Return true if this token has been poisoned.
bool hasRevertedTokenIDToIdentifier() const
True if revertTokenIDToIdentifier() was called.
tok::NotableIdentifierKind getNotableIdentifierID() const
void setOutOfDate(bool OOD)
Set whether the information for this identifier is out of date with respect to the external source.
tok::ObjCKeywordKind getObjCKeywordID() const
Return the Objective-C keyword ID for the this identifier.
void setObjCOrBuiltinID(unsigned ID)
void revertTokenIDToIdentifier()
Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2 compatibility.
bool isOutOfDate() const
Determine whether the information for this identifier is out of date with respect to the external sou...
void setChangedSinceDeserialization()
Note that this identifier has changed since it was loaded from an AST file.
void * getFETokenInfo() const
Get and set FETokenInfo.
StringRef getName() const
Return the actual identifier string.
bool isExtensionToken() const
get/setExtension - Initialize information about whether or not this language token is an extension.
An iterator that walks over all of the known identifiers in the lookup table.
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)
Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn't alre...
llvm::iterator_range< iterator > decls(DeclarationName Name)
Returns a range of decls with the name 'Name'.
Implements an efficient mapping from strings to IdentifierInfo nodes.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
In-memory cache for modules.
llvm::MemoryBuffer * lookupPCM(llvm::StringRef Filename) const
Get a pointer to the pCM if it exists; else nullptr.
Record the location of an inclusion directive, such as an #include or #import statement.
InclusionKind
The kind of inclusion directives known to the preprocessor.
Represents a field injected from an anonymous union/struct into the parent scope.
Wrapper for source info for injected class names of class templates.
void setAmpLoc(SourceLocation Loc)
PragmaMSPointersToMembersKind
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
clang::ObjCRuntime ObjCRuntime
SanitizerSet Sanitize
Set of enabled sanitizers.
CommentOptions CommentOpts
Options for parsing comments.
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
std::string CurrentModule
The name of the current module, of which the main source file is a part.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
An UnresolvedSet-like class that might not have been loaded from the external AST source yet.
Used to hold and unique data used to represent #line information.
unsigned getLineTableFilenameID(StringRef Str)
void AddEntry(FileID FID, const std::vector< LineEntry > &Entries)
Add a new line entry that has already been encoded into the internal representation of the line table...
Record the location of a macro definition.
Encapsulates changes to the "macros namespace" (the location where the macro name became active,...
void setPrevious(MacroDirective *Prev)
Set previous definition of the macro with the same name.
Records the location of a macro expansion.
Encapsulates the data about a macro definition (e.g.
void setUsedForHeaderGuard(bool Val)
void setHasCommaPasting()
void setDefinitionEndLoc(SourceLocation EndLoc)
Set the location of the last token in the macro.
void setParameterList(ArrayRef< IdentifierInfo * > List, llvm::BumpPtrAllocator &PPAllocator)
Set the specified list of identifiers as the parameter list for this macro.
llvm::MutableArrayRef< Token > allocateTokens(unsigned NumTokens, llvm::BumpPtrAllocator &PPAllocator)
void setIsFunctionLike()
Function/Object-likeness.
void setIsC99Varargs()
Varargs querying methods. This can only be set for function-like macros.
void setIsUsed(bool Val)
Set the value of the IsUsed flag.
void setExpansionLoc(SourceLocation Loc)
void setAttrRowOperand(Expr *e)
void setAttrColumnOperand(Expr *e)
void setAttrOperandParensRange(SourceRange range)
void setAttrNameLoc(SourceLocation loc)
Wrapper for source info for member pointers.
void setStarLoc(SourceLocation Loc)
void setClassTInfo(TypeSourceInfo *TI)
void addLinkAsDependency(Module *Mod)
Make module to use export_as as the link dependency name if enough information is available or add it...
std::pair< Module *, bool > findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework, bool IsExplicit)
Find a new module or submodule, or create it if it does not already exist.
void setUmbrellaDirAsWritten(Module *Mod, DirectoryEntryRef UmbrellaDir, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)
Sets the umbrella directory of the given module to the given directory.
void setUmbrellaHeaderAsWritten(Module *Mod, FileEntryRef UmbrellaHeader, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)
Sets the umbrella header of the given module to the given header.
void resolveLinkAsDependencies(Module *Mod)
Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...
ModuleHeaderRole
Flags describing the role of a module header.
void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)
Adds this header to the given module.
Describes a module or submodule.
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
void addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target)
Add the given feature requirement to the list of features required by this module.
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
unsigned IsUnimportable
Whether this module has declared itself unimportable, either because it's missing a requirement from ...
NameVisibilityKind NameVisibility
The visibility of names within this particular module.
NameVisibilityKind
Describes the visibility of the various names within a particular module.
@ Hidden
All of the names in this module are hidden.
@ AllVisible
All of the names in this module are visible.
SourceLocation DefinitionLoc
The location of the module definition.
SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders
Headers that are mentioned in the module map file but could not be found on the file system.
ModuleKind Kind
The kind of this module.
void addTopHeaderFilename(StringRef Filename)
Add a top-level header filename associated with this module.
bool isUnimportable() const
Determine whether this module has been declared unimportable.
void setASTFile(OptionalFileEntryRef File)
Set the serialized AST file for the top-level module of this module.
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers).
std::string Name
The name of this module.
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...
unsigned ModuleMapIsPrivate
Whether this module came from a "private" module map, found next to a regular (public) module map.
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used.
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
std::optional< Header > getUmbrellaHeaderAsWritten() const
Retrieve the umbrella header as written.
SmallVector< Requirement, 2 > Requirements
The set of language features required to use this module.
OptionalDirectoryEntryRef Directory
The build directory of this module.
unsigned NamedModuleHasInit
Whether this C++20 named modules doesn't need an initializer.
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
ASTFileSignature Signature
The module signature.
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e....
void getExportedModules(SmallVectorImpl< Module * > &Exported) const
Appends this module's list of exported modules to Exported.
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
std::optional< DirectoryName > getUmbrellaDirAsWritten() const
Retrieve the umbrella directory as written.
std::string ExportAsModule
The module through which entities defined in this module will eventually be exposed,...
unsigned IsAvailable
Whether this module is available in the current translation unit.
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
OptionalFileEntryRef getASTFile() const
The serialized AST file for this module, if one was created.
std::vector< Conflict > Conflicts
The list of conflicts.
This represents a decl that may have a name.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a C++ namespace alias.
Represent a C++ namespace.
Class that aids in the construction of nested-name-specifiers along with source-location information ...
A C++ nested-name-specifier augmented with source location information.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
static std::string getOwningModuleNameForDiagnostic(const Decl *D)
Get the best name we know for the module that owns the given declaration, or an empty string if the d...
This represents 'acq_rel' clause in the '#pragma omp atomic|flush' directives.
This represents 'acquire' clause in the '#pragma omp atomic|flush' directives.
This represents clause 'affinity' in the '#pragma omp task'-based directives.
static OMPAffinityClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N locator items.
This represents the 'align' clause in the '#pragma omp allocate' directive.
This represents clause 'aligned' in the '#pragma omp ...' directives.
static OMPAlignedClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
This represents clause 'allocate' in the '#pragma omp ...' directives.
static OMPAllocateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'allocator' clause in the '#pragma omp ...' directive.
This represents 'at' clause in the '#pragma omp error' directive.
This represents 'atomic_default_mem_order' clause in the '#pragma omp requires' directive.
This represents 'bind' clause in the '#pragma omp ...' directives.
static OMPBindClause * CreateEmpty(const ASTContext &C)
Build an empty 'bind' clause.
This represents 'capture' clause in the '#pragma omp atomic' directive.
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C)
OMPClauseReader(ASTRecordReader &Record)
void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C)
RetTy Visit(PTR(OMPClause) S)
Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc.
Class that handles pre-initialization statement for some clauses, like 'shedule', 'firstprivate' etc.
This is a basic class for representing single OpenMP clause.
This represents 'collapse' clause in the '#pragma omp ...' directive.
This represents 'compare' clause in the '#pragma omp atomic' directive.
This represents clause 'copyin' in the '#pragma omp ...' directives.
static OMPCopyinClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
static OMPCopyprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'default' clause in the '#pragma omp ...' directive.
This represents 'defaultmap' clause in the '#pragma omp ...' directive.
This represents implicit clause 'depend' for the '#pragma omp task' directive.
static OMPDependClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N variables.
This represents implicit clause 'depobj' for the '#pragma omp depobj' directive.
static OMPDepobjClause * CreateEmpty(const ASTContext &C)
Creates an empty clause.
This represents 'destroy' clause in the '#pragma omp depobj' directive or the '#pragma omp interop' d...
This represents 'detach' clause in the '#pragma omp task' directive.
This represents 'device' clause in the '#pragma omp ...' directive.
This represents 'dist_schedule' clause in the '#pragma omp ...' directive.
This represents the 'doacross' clause for the '#pragma omp ordered' directive.
static OMPDoacrossClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N expressions.
This represents 'dynamic_allocators' clause in the '#pragma omp requires' directive.
This represents clause 'exclusive' in the '#pragma omp scan' directive.
static OMPExclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'fail' clause in the '#pragma omp atomic' directive.
This represents 'filter' clause in the '#pragma omp ...' directive.
This represents 'final' clause in the '#pragma omp ...' directive.
This represents clause 'firstprivate' in the '#pragma omp ...' directives.
static OMPFirstprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents implicit clause 'flush' for the '#pragma omp flush' directive.
static OMPFlushClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents clause 'from' in the '#pragma omp ...' directives.
static OMPFromClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
Representation of the 'full' clause of the '#pragma omp unroll' directive.
static OMPFullClause * CreateEmpty(const ASTContext &C)
Build an empty 'full' AST node for deserialization.
This represents 'grainsize' clause in the '#pragma omp ...' directive.
This represents clause 'has_device_ptr' in the '#pragma omp ...' directives.
static OMPHasDeviceAddrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents 'hint' clause in the '#pragma omp ...' directive.
This represents 'if' clause in the '#pragma omp ...' directive.
This represents clause 'in_reduction' in the '#pragma omp task' directives.
static OMPInReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents clause 'inclusive' in the '#pragma omp scan' directive.
static OMPInclusiveClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents the 'init' clause in '#pragma omp ...' directives.
static OMPInitClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N expressions.
This represents clause 'is_device_ptr' in the '#pragma omp ...' directives.
static OMPIsDevicePtrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'lastprivate' in the '#pragma omp ...' directives.
static OMPLastprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents clause 'linear' in the '#pragma omp ...' directives.
static OMPLinearClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
This represents clause 'map' in the '#pragma omp ...' directives.
static OMPMapClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars original expressions, NumUniqueDeclarations declar...
This represents 'mergeable' clause in the '#pragma omp ...' directive.
This represents 'message' clause in the '#pragma omp error' directive.
This represents 'nocontext' clause in the '#pragma omp ...' directive.
This represents 'nogroup' clause in the '#pragma omp ...' directive.
This represents clause 'nontemporal' in the '#pragma omp ...' directives.
static OMPNontemporalClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'novariants' clause in the '#pragma omp ...' directive.
This represents 'nowait' clause in the '#pragma omp ...' directive.
This represents 'num_tasks' clause in the '#pragma omp ...' directive.
This represents 'num_teams' clause in the '#pragma omp ...' directive.
This represents 'num_threads' clause in the '#pragma omp ...' directive.
This represents 'order' clause in the '#pragma omp ...' directive.
This represents 'ordered' clause in the '#pragma omp ...' directive.
static OMPOrderedClause * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty clause.
Representation of the 'partial' clause of the '#pragma omp unroll' directive.
static OMPPartialClause * CreateEmpty(const ASTContext &C)
Build an empty 'partial' AST node for deserialization.
This represents 'priority' clause in the '#pragma omp ...' directive.
This represents clause 'private' in the '#pragma omp ...' directives.
static OMPPrivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'proc_bind' clause in the '#pragma omp ...' directive.
This represents 'read' clause in the '#pragma omp atomic' directive.
This represents clause 'reduction' in the '#pragma omp ...' directives.
static OMPReductionClause * CreateEmpty(const ASTContext &C, unsigned N, OpenMPReductionClauseModifier Modifier)
Creates an empty clause with the place for N variables.
This represents 'relaxed' clause in the '#pragma omp atomic' directives.
This represents 'release' clause in the '#pragma omp atomic|flush' directives.
This represents 'reverse_offload' clause in the '#pragma omp requires' directive.
This represents 'simd' clause in the '#pragma omp ...' directive.
This represents 'safelen' clause in the '#pragma omp ...' directive.
This represents 'schedule' clause in the '#pragma omp ...' directive.
This represents 'seq_cst' clause in the '#pragma omp atomic' directive.
This represents 'severity' clause in the '#pragma omp error' directive.
This represents clause 'shared' in the '#pragma omp ...' directives.
static OMPSharedClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents 'simdlen' clause in the '#pragma omp ...' directive.
This represents the 'sizes' clause in the '#pragma omp tile' directive.
static OMPSizesClause * CreateEmpty(const ASTContext &C, unsigned NumSizes)
Build an empty 'sizes' AST node for deserialization.
This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives.
static OMPTaskReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents 'thread_limit' clause in the '#pragma omp ...' directive.
This represents 'threads' clause in the '#pragma omp ...' directive.
This represents clause 'to' in the '#pragma omp ...' directives.
static OMPToClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
llvm::SmallVector< OMPTraitSet, 2 > Sets
The outermost level of selector sets.
This represents 'unified_address' clause in the '#pragma omp requires' directive.
This represents 'unified_shared_memory' clause in the '#pragma omp requires' directive.
This represents 'untied' clause in the '#pragma omp ...' directive.
This represents 'update' clause in the '#pragma omp atomic' directive.
static OMPUpdateClause * CreateEmpty(const ASTContext &C, bool IsExtended)
Creates an empty clause with the place for N variables.
This represents the 'use' clause in '#pragma omp ...' directives.
This represents clause 'use_device_addr' in the '#pragma omp ...' directives.
static OMPUseDeviceAddrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'use_device_ptr' in the '#pragma omp ...' directives.
static OMPUseDevicePtrClause * CreateEmpty(const ASTContext &C, const OMPMappableExprListSizeTy &Sizes)
Creates an empty clause with the place for NumVars variables.
This represents clause 'uses_allocators' in the '#pragma omp target'-based directives.
static OMPUsesAllocatorsClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N allocators.
This represents 'weak' clause in the '#pragma omp atomic' directives.
This represents 'write' clause in the '#pragma omp atomic' directive.
This represents 'ompx_attribute' clause in a directive that might generate an outlined function.
This represents 'ompx_bare' clause in the '#pragma omp target teams ...' directive.
This represents 'ompx_dyn_cgroup_mem' clause in the '#pragma omp target ...' directive.
method_range methods() const
Represents an ObjC class declaration.
Wrapper for source info for ObjC interfaces.
void setNameLoc(SourceLocation Loc)
void setNameEndLoc(SourceLocation Loc)
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCMethodDecl - Represents an instance or class method declaration.
bool hasBody() const override
Determine whether this method has a body.
Selector getSelector() const
bool isInstanceMethod() const
void setLazyBody(uint64_t Offset)
Wraps an ObjCPointerType with source location information.
void setStarLoc(SourceLocation Loc)
void setTypeArgsRAngleLoc(SourceLocation Loc)
unsigned getNumTypeArgs() const
unsigned getNumProtocols() const
void setTypeArgsLAngleLoc(SourceLocation Loc)
void setTypeArgTInfo(unsigned i, TypeSourceInfo *TInfo)
void setProtocolLAngleLoc(SourceLocation Loc)
void setProtocolRAngleLoc(SourceLocation Loc)
void setHasBaseTypeAsWritten(bool HasBaseType)
void setProtocolLoc(unsigned i, SourceLocation Loc)
Represents an Objective-C protocol declaration.
The basic abstraction for the target Objective-C runtime.
Kind
The basic Objective-C runtimes that we know about.
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
unsigned getNumProtocols() const
void setProtocolLoc(unsigned i, SourceLocation Loc)
void setProtocolLAngleLoc(SourceLocation Loc)
void setProtocolRAngleLoc(SourceLocation Loc)
static OpenACCAsyncClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCAttachClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
This is the base type for all OpenACC Clauses.
static OpenACCCopyClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCopyInClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsReadOnly, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCopyOutClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCreateClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDefaultClause * Create(const ASTContext &C, OpenACCDefaultClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
static OpenACCDevicePtrClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDeviceTypeClause * Create(const ASTContext &C, OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< DeviceTypeArgument > Archs, SourceLocation EndLoc)
static OpenACCFirstPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCIfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
static OpenACCNoCreateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCNumGangsClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > IntExprs, SourceLocation EndLoc)
static OpenACCNumWorkersClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCPresentClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCSelfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
static OpenACCVectorLengthClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCWaitClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef< Expr * > QueueIdExprs, SourceLocation EndLoc)
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
virtual llvm::StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const =0
Returns the serialized AST inside the PCH container Buffer.
ASTReaderListener implementation to validate the information of the PCH file against an initialized P...
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
void setEllipsisLoc(SourceLocation Loc)
void setEllipsisLoc(SourceLocation Loc)
void setRParenLoc(SourceLocation Loc)
void setLParenLoc(SourceLocation Loc)
Represents a parameter to a function.
void setKWLoc(SourceLocation Loc)
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
Base class that describes a preprocessed entity, which may be a preprocessor directive or macro expan...
Iteration over the preprocessed entities.
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::string > MacroIncludes
std::vector< std::string > Includes
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
std::string PCHThroughHeader
If non-empty, the filename used in an #include directive in the primary source file (or command-line ...
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
bool AllowPCHWithDifferentModulesCachePath
When true, a PCH with modules cache path different to the current compilation will not be rejected.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
std::vector< std::pair< std::string, bool > > Macros
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Module * getCurrentModule()
Retrieves the module that we're currently building, if any.
const TargetInfo & getTargetInfo() const
FileManager & getFileManager() const
PreprocessorOptions & getPreprocessorOpts() const
Retrieve the preprocessor options used to initialize this preprocessor.
HeaderSearch & getHeaderSearchInfo() const
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
void setCounterValue(unsigned V)
DiagnosticsEngine & getDiagnostics() const
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Wrapper of type source information for a type with non-trivial direct qualifiers.
The collection of all-type qualifiers we support.
@ FastWidth
The width of the "fast" qualifier mask.
@ FastMask
The fast qualifier mask.
void setAmpAmpLoc(SourceLocation Loc)
Represents a struct/union/class.
Wrapper for source info for record types.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
This table allows us to fully hide how we implement multi-keyword caching.
Selector getNullarySelector(const IdentifierInfo *ID)
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Selector getUnarySelector(const IdentifierInfo *ID)
Smart pointer class that efficiently represents Objective-C method names.
std::pair< iterator, bool > insert(std::pair< Selector, Lists > &&Val)
iterator find(Selector Sel)
llvm::DenseMap< Selector, Lists >::iterator iterator
std::pair< ObjCMethodList, ObjCMethodList > Lists
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Sema - This implements semantic analysis and AST building for C.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
IdentifierResolver IdResolver
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
This object establishes a SourceLocationSequence.
Serialized encoding of a sequence of SourceLocations.
Encodes a location in the source.
static SourceLocation getFromRawEncoding(UIntTy Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
SourceLocation getFileLoc(SourceLocation Loc) const
Given Loc, if it is a macro location return the expansion location or the spelling location,...
void setExternalSLocEntrySource(ExternalSLocEntrySource *Source)
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
One instance of this struct is kept for every file loaded or used.
OptionalFileEntryRef ContentsEntry
References the file which the contents were actually loaded from.
std::optional< llvm::MemoryBufferRef > getBufferIfLoaded() const
Return the buffer, only if it has been loaded.
unsigned BufferOverridden
Indicates whether the buffer itself was provided to override the actual file contents.
OptionalFileEntryRef OrigEntry
Reference to the file entry representing this ContentCache.
Information about a FileID, basically just the logical file that it represents and include stack info...
void setHasLineDirectives()
Set the flag that indicates that this FileID has line table entries associated with it.
Stmt - This represents one statement.
DiagnosticStorage * getStorage() const
Retrieve storage for this particular diagnostic.
Wrapper for substituted template type parameters.
Wrapper for substituted template type parameters.
Represents the declaration of a struct/union/class/enum.
TagDecl * getDecl() const
TargetOptions & getTargetOpts() const
Retrieve the target options.
Options for controlling the target.
std::string Triple
The name of the target triple to compile for.
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
std::string ABI
If given, the name of the target ABI to use.
std::string TuneCPU
If given, the name of the target CPU to tune code for.
std::string CPU
If given, the name of the target CPU to generate code for.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line.
A convenient class for passing around template argument information.
Location wrapper for a TemplateArgument.
Represents a template argument.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
ArgKind
The kind of template argument we're storing.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
Stores a list of template parameters for a TemplateDecl and its derived classes.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
unsigned getNumArgs() const
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateKeywordLoc(SourceLocation Loc)
void setTemplateNameLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
ArrayRef< TemplateArgument > template_arguments() const
Wrapper for template type parameters.
Token - This structure provides full information about a lexed token.
void setAnnotationEndLoc(SourceLocation L)
void setLength(unsigned Len)
void setKind(tok::TokenKind K)
tok::TokenKind getKind() const
void setLocation(SourceLocation L)
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
void setAnnotationValue(void *val)
void startToken()
Reset all flags to cleared.
void setIdentifierInfo(IdentifierInfo *II)
void setFlag(TokenFlags Flag)
Set the specified flag.
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
void VisitArrayTypeLoc(ArrayTypeLoc)
void VisitFunctionTypeLoc(FunctionTypeLoc)
TypeLocReader(ASTRecordReader &Reader, LocSeq *Seq)
RetTy Visit(TypeLoc TyLoc)
Base wrapper for a particular "section" of type source info.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
void setUnmodifiedTInfo(TypeSourceInfo *TI) const
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
void setNameLoc(SourceLocation Loc)
The base class of the type hierarchy.
const T * getAs() const
Member-template getAs<specific type>'.
Base class for declarations which introduce a typedef-name.
Wrapper for source info for typedefs.
void setLParenLoc(SourceLocation Loc)
void setTypeofLoc(SourceLocation Loc)
void setRParenLoc(SourceLocation Loc)
Wrapper for source info for unresolved typename using decls.
Wrapper for source info for types used via transparent aliases.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
void setNameLoc(SourceLocation Loc)
Captures information about a #pragma weak directive.
Source location and bit offset of a declaration.
A key used when looking up entities by DeclarationName.
unsigned getHash() const
Compute a fingerprint of this key for use in on-disk hash table.
DeclarationNameKey()=default
Information about a module that has been loaded by the ASTReader.
const PPEntityOffset * PreprocessedEntityOffsets
void * IdentifierLookupTable
A pointer to an on-disk hash table of opaque type IdentifierHashTable.
serialization::DeclID BaseDeclID
Base declaration ID for declarations local to this module.
void * SelectorLookupTable
A pointer to an on-disk hash table of opaque type ASTSelectorLookupTable.
std::vector< std::unique_ptr< ModuleFileExtensionReader > > ExtensionReaders
The list of extension readers that are attached to this module file.
SourceLocation DirectImportLoc
The source location where the module was explicitly or implicitly imported in the local translation u...
StringRef Data
The serialized bitstream data for this file.
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID.
ContinuousRangeMap< uint32_t, int, 2 > PreprocessedEntityRemap
Remapping table for preprocessed entity IDs in this module.
int SLocEntryBaseID
The base ID in the source manager's view of this module.
serialization::IdentifierID BaseIdentifierID
Base identifier ID for identifiers local to this module.
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
serialization::TypeID BaseTypeIndex
Base type ID for types local to this module as represented in the global type ID space.
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
uint64_t MacroOffsetsBase
Base file offset for the offsets in MacroOffsets.
const llvm::support::unaligned_uint64_t * InputFileOffsets
Relative offsets for all of the input file entries in the AST file.
std::vector< unsigned > PreloadIdentifierOffsets
Offsets of identifiers that we're going to preload within IdentifierTableData.
unsigned LocalNumIdentifiers
The number of identifiers in this AST file.
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
const unsigned char * IdentifierTableData
Actual data for the on-disk hash table of identifiers.
uint64_t SLocEntryOffsetsBase
Base file offset for the offsets in SLocEntryOffsets.
llvm::BitstreamCursor InputFilesCursor
The cursor to the start of the input-files block.
std::vector< InputFile > InputFilesLoaded
The input files that have been loaded from this AST file.
serialization::SelectorID BaseSelectorID
Base selector ID for selectors local to this module.
llvm::SetVector< ModuleFile * > ImportedBy
List of modules which depend on this module.
const char * HeaderFileInfoTableData
Actual data for the on-disk hash table of header file information.
SourceLocation ImportLoc
The source location where this module was first imported.
ContinuousRangeMap< uint32_t, int, 2 > TypeRemap
Remapping table for type IDs in this module.
const uint32_t * SLocEntryOffsets
Offsets for all of the source location entries in the AST file.
llvm::BitstreamCursor MacroCursor
The cursor to the start of the preprocessor block, which stores all of the macro definitions.
FileID OriginalSourceFileID
The file ID for the original source file that was used to build this AST file.
FileEntryRef File
The file entry for the module file.
llvm::SmallVector< ModuleFile *, 16 > DependentModules
List of modules which this modules dependent on.
std::string ActualOriginalSourceFileName
The actual original source file name that was used to build this AST file.
ContinuousRangeMap< uint32_t, int, 2 > IdentifierRemap
Remapping table for identifier IDs in this module.
const LocalDeclID * FileSortedDecls
Array of file-level DeclIDs sorted by file.
uint64_t PreprocessorDetailStartOffset
The offset of the start of the preprocessor detail cursor.
std::vector< InputFileInfo > InputFileInfosLoaded
The input file infos that have been loaded from this AST file.
unsigned LocalNumSubmodules
The number of submodules in this module.
SourceLocation FirstLoc
The first source location in this module.
ASTFileSignature ASTBlockHash
The signature of the AST block of the module file, this can be used to unique module files based on A...
uint64_t SourceManagerBlockStartOffset
The bit offset to the start of the SOURCE_MANAGER_BLOCK.
bool DidReadTopLevelSubmodule
Whether the top-level module has been read from the AST file.
std::string OriginalSourceFileName
The original source file name that was used to build the primary AST file, which may have been modifi...
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
bool HasTimestamps
Whether timestamps are included in this module file.
uint64_t InputFilesOffsetBase
Absolute offset of the start of the input-files block.
llvm::BitstreamCursor SLocEntryCursor
Cursor used to read source location entries.
unsigned NumPreprocessedEntities
bool RelocatablePCH
Whether this precompiled header is a relocatable PCH file.
const uint32_t * SelectorOffsets
Offsets into the selector lookup table's data array where each selector resides.
unsigned NumFileSortedDecls
unsigned LocalNumSLocEntries
The number of source location entries in this AST file.
void * HeaderFileInfoTable
The on-disk hash table that contains information about each of the header files.
unsigned NumUserInputFiles
llvm::BitstreamCursor Stream
The main bitstream cursor for the main block.
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
uint64_t SizeInBits
The size of this file, in bits.
const UnalignedUInt64 * TypeOffsets
Offset of each type within the bitstream, indexed by the type ID, or the representation of a Type*.
uint64_t GlobalBitOffset
The global bit offset (or base) of this module.
bool StandardCXXModule
Whether this module file is a standard C++ module.
unsigned LocalNumTypes
The number of types in this AST file.
StringRef ModuleOffsetMap
The module offset map data for this file.
const PPSkippedRange * PreprocessedSkippedRangeOffsets
std::string FileName
The file name of the module file.
uint64_t InputFilesValidationTimestamp
If non-zero, specifies the time when we last validated input files.
llvm::BitstreamCursor PreprocessorDetailCursor
The cursor to the start of the (optional) detailed preprocessing record block.
SourceLocation::UIntTy SLocEntryBaseOffset
The base offset in the source manager's view of this module.
std::string ModuleMapPath
const DeclOffset * DeclOffsets
Offset of each declaration within the bitstream, indexed by the declaration ID (-1).
std::string getTimestampFilename() const
uint64_t MacroStartOffset
The offset of the start of the set of defined macros.
ASTFileSignature Signature
The signature of the module file, which may be used instead of the size and modification time to iden...
unsigned LocalNumMacros
The number of macros in this AST file.
ContinuousRangeMap< serialization::DeclID, int, 2 > DeclRemap
Remapping table for declaration IDs in this module.
unsigned NumPreprocessedSkippedRanges
const unsigned char * SelectorLookupTableData
A pointer to the character data that comprises the selector table.
void dump()
Dump debugging output for this module.
unsigned LocalNumDecls
The number of declarations in this AST file.
unsigned LocalNumHeaderFileInfos
The number of local HeaderFileInfo structures.
llvm::BitVector SearchPathUsage
The bit vector denoting usage of each header search entry (true = used).
unsigned Generation
The generation of which this module file is a part.
const uint32_t * IdentifierOffsets
Offsets into the identifier table data.
ContinuousRangeMap< uint32_t, int, 2 > SelectorRemap
Remapping table for selector IDs in this module.
llvm::DenseMap< ModuleFile *, serialization::DeclID > GlobalToLocalDeclIDs
Mapping from the module files that this module file depends on to the base declaration ID for that mo...
ContinuousRangeMap< uint32_t, int, 2 > MacroRemap
Remapping table for macro IDs in this module.
const uint32_t * MacroOffsets
Offsets of macros in the preprocessor block.
uint64_t ASTBlockStartOffset
The bit offset of the AST block of this module.
ContinuousRangeMap< uint32_t, int, 2 > SubmoduleRemap
Remapping table for submodule IDs in this module.
llvm::BitVector VFSUsage
The bit vector denoting usage of each VFS entry (true = used).
uint64_t DeclsBlockStartOffset
The offset to the start of the DECLTYPES_BLOCK block.
SmallVector< uint64_t, 8 > PragmaDiagMappings
Diagnostic IDs and their mappings that the user changed.
unsigned BasePreprocessedSkippedRangeID
Base ID for preprocessed skipped ranges local to this module.
unsigned LocalNumSelectors
The number of selectors new to this file.
ModuleKind Kind
The type of this module.
std::string ModuleName
The name of the module.
serialization::MacroID BaseMacroID
Base macro ID for macros local to this module.
SmallVector< uint64_t, 1 > ObjCCategories
The Objective-C category lists for categories known to this module.
std::string BaseDirectory
The base directory of the module.
Manages the set of modules loaded by an AST reader.
ModuleFile & getPrimaryModule()
Returns the primary module associated with the manager, that is, the first module loaded.
AddModuleResult
The result of attempting to add a new module.
@ Missing
The module file is missing.
@ OutOfDate
The module file is out-of-date.
@ NewlyLoaded
The module file was just loaded in response to this call.
@ AlreadyLoaded
The module file had already been loaded.
llvm::iterator_range< SmallVectorImpl< ModuleFile * >::const_iterator > pch_modules() const
A range covering the PCH and preamble module files loaded.
ModuleReverseIterator rbegin()
Reverse iterator to traverse all loaded modules.
void visit(llvm::function_ref< bool(ModuleFile &M)> Visitor, llvm::SmallPtrSetImpl< ModuleFile * > *ModuleFilesHit=nullptr)
Visit each of the modules.
unsigned size() const
Number of modules loaded.
Source range/offset of a preprocessed entity.
uint32_t getOffset() const
RawLocEncoding getBegin() const
RawLocEncoding getEnd() const
Source range of a skipped preprocessor region.
RawLocEncoding getBegin() const
RawLocEncoding getEnd() const
unsigned getFactoryBits() const
ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, unsigned PriorGeneration)
ArrayRef< ObjCMethodDecl * > getInstanceMethods() const
Retrieve the instance methods found by this visitor.
ArrayRef< ObjCMethodDecl * > getFactoryMethods() const
Retrieve the instance methods found by this visitor.
bool instanceHasMoreThanOneDecl() const
bool operator()(ModuleFile &M)
bool factoryHasMoreThanOneDecl() const
unsigned getInstanceBits() const
static TypeIdx fromTypeID(TypeID ID)
32 aligned uint64_t in the AST file.
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
static hash_value_type ComputeHash(const internal_key_type &a)
StringRef internal_key_type
static internal_key_type ReadKey(const unsigned char *d, unsigned n)
Class that performs lookup for an identifier stored in an AST file.
IdentifierID ReadIdentifierID(const unsigned char *d)
data_type ReadData(const internal_key_type &k, const unsigned char *d, unsigned DataLen)
Class that performs lookup for a selector's entries in the global method pool stored in an AST file.
internal_key_type ReadKey(const unsigned char *d, unsigned)
data_type ReadData(Selector, const unsigned char *d, unsigned DataLen)
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
static hash_value_type ComputeHash(Selector Sel)
PredefinedTypeIDs
Predefined type IDs.
CtorInitializerType
The different kinds of data that can occur in a CtorInitializer.
const unsigned NUM_PREDEF_TYPE_IDS
The number of predefined type IDs that are reserved for the PREDEF_TYPE_* constants.
const unsigned NumSpecialTypeIDs
The number of special type IDs.
TypeCode
Record codes for each kind of type.
@ PREDEF_TYPE_LONG_ACCUM_ID
The 'long _Accum' type.
@ PREDEF_TYPE_SAMPLER_ID
OpenCL sampler type.
@ PREDEF_TYPE_INT128_ID
The '__int128_t' type.
@ PREDEF_TYPE_CHAR32_ID
The C++ 'char32_t' type.
@ PREDEF_TYPE_SAT_SHORT_ACCUM_ID
The '_Sat short _Accum' type.
@ PREDEF_TYPE_IBM128_ID
The '__ibm128' type.
@ PREDEF_TYPE_SHORT_FRACT_ID
The 'short _Fract' type.
@ PREDEF_TYPE_AUTO_RREF_DEDUCT
The "auto &&" deduction type.
@ PREDEF_TYPE_BOUND_MEMBER
The placeholder type for bound member functions.
@ PREDEF_TYPE_LONGLONG_ID
The (signed) 'long long' type.
@ PREDEF_TYPE_FRACT_ID
The '_Fract' type.
@ PREDEF_TYPE_ARC_UNBRIDGED_CAST
ARC's unbridged-cast placeholder type.
@ PREDEF_TYPE_USHORT_FRACT_ID
The 'unsigned short _Fract' type.
@ PREDEF_TYPE_SAT_ULONG_FRACT_ID
The '_Sat unsigned long _Fract' type.
@ PREDEF_TYPE_BOOL_ID
The 'bool' or '_Bool' type.
@ PREDEF_TYPE_SAT_LONG_ACCUM_ID
The '_Sat long _Accum' type.
@ PREDEF_TYPE_SAT_LONG_FRACT_ID
The '_Sat long _Fract' type.
@ PREDEF_TYPE_SAT_SHORT_FRACT_ID
The '_Sat short _Fract' type.
@ PREDEF_TYPE_CHAR_U_ID
The 'char' type, when it is unsigned.
@ PREDEF_TYPE_RESERVE_ID_ID
OpenCL reserve_id type.
@ PREDEF_TYPE_SAT_ACCUM_ID
The '_Sat _Accum' type.
@ PREDEF_TYPE_BUILTIN_FN
The placeholder type for builtin functions.
@ PREDEF_TYPE_SHORT_ACCUM_ID
The 'short _Accum' type.
@ PREDEF_TYPE_FLOAT_ID
The 'float' type.
@ PREDEF_TYPE_QUEUE_ID
OpenCL queue type.
@ PREDEF_TYPE_INT_ID
The (signed) 'int' type.
@ PREDEF_TYPE_OBJC_SEL
The ObjC 'SEL' type.
@ PREDEF_TYPE_BFLOAT16_ID
The '__bf16' type.
@ PREDEF_TYPE_WCHAR_ID
The C++ 'wchar_t' type.
@ PREDEF_TYPE_UCHAR_ID
The 'unsigned char' type.
@ PREDEF_TYPE_UACCUM_ID
The 'unsigned _Accum' type.
@ PREDEF_TYPE_SCHAR_ID
The 'signed char' type.
@ PREDEF_TYPE_CHAR_S_ID
The 'char' type, when it is signed.
@ PREDEF_TYPE_NULLPTR_ID
The type of 'nullptr'.
@ PREDEF_TYPE_ULONG_FRACT_ID
The 'unsigned long _Fract' type.
@ PREDEF_TYPE_FLOAT16_ID
The '_Float16' type.
@ PREDEF_TYPE_UINT_ID
The 'unsigned int' type.
@ PREDEF_TYPE_FLOAT128_ID
The '__float128' type.
@ PREDEF_TYPE_OBJC_ID
The ObjC 'id' type.
@ PREDEF_TYPE_CHAR16_ID
The C++ 'char16_t' type.
@ PREDEF_TYPE_ARRAY_SECTION
The placeholder type for an array section.
@ PREDEF_TYPE_ULONGLONG_ID
The 'unsigned long long' type.
@ PREDEF_TYPE_SAT_UFRACT_ID
The '_Sat unsigned _Fract' type.
@ PREDEF_TYPE_USHORT_ID
The 'unsigned short' type.
@ PREDEF_TYPE_SHORT_ID
The (signed) 'short' type.
@ PREDEF_TYPE_OMP_ARRAY_SHAPING
The placeholder type for OpenMP array shaping operation.
@ PREDEF_TYPE_DEPENDENT_ID
The placeholder type for dependent types.
@ PREDEF_TYPE_LONGDOUBLE_ID
The 'long double' type.
@ PREDEF_TYPE_DOUBLE_ID
The 'double' type.
@ PREDEF_TYPE_UINT128_ID
The '__uint128_t' type.
@ PREDEF_TYPE_HALF_ID
The OpenCL 'half' / ARM NEON __fp16 type.
@ PREDEF_TYPE_VOID_ID
The void type.
@ PREDEF_TYPE_SAT_USHORT_FRACT_ID
The '_Sat unsigned short _Fract' type.
@ PREDEF_TYPE_ACCUM_ID
The '_Accum' type.
@ PREDEF_TYPE_SAT_FRACT_ID
The '_Sat _Fract' type.
@ PREDEF_TYPE_NULL_ID
The NULL type.
@ PREDEF_TYPE_USHORT_ACCUM_ID
The 'unsigned short _Accum' type.
@ PREDEF_TYPE_CHAR8_ID
The C++ 'char8_t' type.
@ PREDEF_TYPE_UFRACT_ID
The 'unsigned _Fract' type.
@ PREDEF_TYPE_OVERLOAD_ID
The placeholder type for overloaded function sets.
@ PREDEF_TYPE_INCOMPLETE_MATRIX_IDX
A placeholder type for incomplete matrix index operations.
@ PREDEF_TYPE_UNRESOLVED_TEMPLATE
The placeholder type for unresolved templates.
@ PREDEF_TYPE_SAT_USHORT_ACCUM_ID
The '_Sat unsigned short _Accum' type.
@ PREDEF_TYPE_LONG_ID
The (signed) 'long' type.
@ PREDEF_TYPE_SAT_ULONG_ACCUM_ID
The '_Sat unsigned long _Accum' type.
@ PREDEF_TYPE_LONG_FRACT_ID
The 'long _Fract' type.
@ PREDEF_TYPE_UNKNOWN_ANY
The 'unknown any' placeholder type.
@ PREDEF_TYPE_OMP_ITERATOR
The placeholder type for OpenMP iterator expression.
@ PREDEF_TYPE_PSEUDO_OBJECT
The pseudo-object placeholder type.
@ PREDEF_TYPE_OBJC_CLASS
The ObjC 'Class' type.
@ PREDEF_TYPE_ULONG_ID
The 'unsigned long' type.
@ PREDEF_TYPE_SAT_UACCUM_ID
The '_Sat unsigned _Accum' type.
@ PREDEF_TYPE_CLK_EVENT_ID
OpenCL clk event type.
@ PREDEF_TYPE_EVENT_ID
OpenCL event type.
@ PREDEF_TYPE_ULONG_ACCUM_ID
The 'unsigned long _Accum' type.
@ PREDEF_TYPE_AUTO_DEDUCT
The "auto" deduction type.
@ CTOR_INITIALIZER_MEMBER
@ CTOR_INITIALIZER_DELEGATING
@ CTOR_INITIALIZER_INDIRECT_MEMBER
@ DECL_CXX_BASE_SPECIFIERS
A record containing CXXBaseSpecifiers.
@ DECL_CONTEXT_LEXICAL
A record that stores the set of declarations that are lexically stored within a given DeclContext.
@ DECL_CXX_CTOR_INITIALIZERS
A record containing CXXCtorInitializers.
@ DECL_CONTEXT_VISIBLE
A record that stores the set of declarations that are visible from a given DeclContext.
@ TYPE_EXT_QUAL
An ExtQualType record.
@ SPECIAL_TYPE_OBJC_SEL_REDEFINITION
Objective-C "SEL" redefinition type.
@ SPECIAL_TYPE_UCONTEXT_T
C ucontext_t typedef type.
@ SPECIAL_TYPE_JMP_BUF
C jmp_buf typedef type.
@ SPECIAL_TYPE_FILE
C FILE typedef type.
@ SPECIAL_TYPE_SIGJMP_BUF
C sigjmp_buf typedef type.
@ SPECIAL_TYPE_OBJC_CLASS_REDEFINITION
Objective-C "Class" redefinition type.
@ SPECIAL_TYPE_CF_CONSTANT_STRING
CFConstantString type.
@ SPECIAL_TYPE_OBJC_ID_REDEFINITION
Objective-C "id" redefinition type.
Defines the clang::TargetInfo interface.
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing),...
@ Warning
Present this diagnostic as a warning.
@ Error
Present this diagnostic as an error.
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
llvm::OnDiskChainedHashTable< HeaderFileInfoTrait > HeaderFileInfoLookupTable
The on-disk hash table used for known header files.
llvm::OnDiskIterableChainedHashTable< ASTIdentifierLookupTrait > ASTIdentifierLookupTable
The on-disk hash table used to contain information about all of the identifiers in the program.
llvm::OnDiskChainedHashTable< ASTSelectorLookupTrait > ASTSelectorLookupTable
The on-disk hash table used for the global method pool.
@ EXTENSION_METADATA
Metadata describing this particular extension.
uint32_t TypeID
An ID number that refers to a type in an AST file.
@ SUBMODULE_EXCLUDED_HEADER
Specifies a header that has been explicitly excluded from this submodule.
@ SUBMODULE_TOPHEADER
Specifies a top-level header that falls into this (sub)module.
@ SUBMODULE_PRIVATE_TEXTUAL_HEADER
Specifies a header that is private to this submodule but must be textually included.
@ SUBMODULE_HEADER
Specifies a header that falls into this (sub)module.
@ SUBMODULE_EXPORT_AS
Specifies the name of the module that will eventually re-export the entities in this module.
@ SUBMODULE_UMBRELLA_DIR
Specifies an umbrella directory.
@ SUBMODULE_UMBRELLA_HEADER
Specifies the umbrella header used to create this module, if any.
@ SUBMODULE_METADATA
Metadata for submodules as a whole.
@ SUBMODULE_REQUIRES
Specifies a required feature.
@ SUBMODULE_PRIVATE_HEADER
Specifies a header that is private to this submodule.
@ SUBMODULE_IMPORTS
Specifies the submodules that are imported by this submodule.
@ SUBMODULE_CONFLICT
Specifies a conflict with another module.
@ SUBMODULE_INITIALIZERS
Specifies some declarations with initializers that must be emitted to initialize the module.
@ SUBMODULE_DEFINITION
Defines the major attributes of a submodule, including its name and parent.
@ SUBMODULE_LINK_LIBRARY
Specifies a library or framework to link against.
@ SUBMODULE_CONFIG_MACRO
Specifies a configuration macro for this module.
@ SUBMODULE_EXPORTS
Specifies the submodules that are re-exported from this submodule.
@ SUBMODULE_TEXTUAL_HEADER
Specifies a header that is part of the module but must be textually included.
@ SUBMODULE_AFFECTING_MODULES
Specifies affecting modules that were not imported.
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
OptionsRecordTypes
Record types that occur within the options block inside the control block.
@ FILE_SYSTEM_OPTIONS
Record code for the filesystem options table.
@ TARGET_OPTIONS
Record code for the target options table.
@ PREPROCESSOR_OPTIONS
Record code for the preprocessor options table.
@ HEADER_SEARCH_OPTIONS
Record code for the headers search options table.
@ LANGUAGE_OPTIONS
Record code for the language options table.
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
@ SUBMODULE_BLOCK_ID
The block containing the submodule structure.
@ PREPROCESSOR_DETAIL_BLOCK_ID
The block containing the detailed preprocessing record.
@ AST_BLOCK_ID
The AST block, which acts as a container around the full AST block.
@ SOURCE_MANAGER_BLOCK_ID
The block containing information about the source manager.
@ CONTROL_BLOCK_ID
The control block, which contains all of the information that needs to be validated prior to committi...
@ DECLTYPES_BLOCK_ID
The block containing the definitions of all of the types and decls used within the AST file.
@ PREPROCESSOR_BLOCK_ID
The block containing information about the preprocessor.
@ COMMENTS_BLOCK_ID
The block containing comments.
@ UNHASHED_CONTROL_BLOCK_ID
A block with unhashed content.
@ EXTENSION_BLOCK_ID
A block containing a module file extension.
@ OPTIONS_BLOCK_ID
The block of configuration options, used to check that a module is being used in a configuration comp...
@ INPUT_FILES_BLOCK_ID
The block of input files, which were used as inputs to create this AST file.
CommentRecordTypes
Record types used within a comments block.
@ SM_SLOC_FILE_ENTRY
Describes a source location entry (SLocEntry) for a file.
@ SM_SLOC_BUFFER_BLOB_COMPRESSED
Describes a zlib-compressed blob that contains the data for a buffer entry.
@ SM_SLOC_BUFFER_ENTRY
Describes a source location entry (SLocEntry) for a buffer.
@ SM_SLOC_BUFFER_BLOB
Describes a blob that contains the data for a buffer entry.
@ SM_SLOC_EXPANSION_ENTRY
Describes a source location entry (SLocEntry) for a macro expansion.
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
DeclIDBase::DeclID DeclID
An ID number that refers to a declaration in an AST file.
PreprocessorRecordTypes
Record types used within a preprocessor block.
@ PP_TOKEN
Describes one token.
@ PP_MACRO_FUNCTION_LIKE
A function-like macro definition.
@ PP_MACRO_OBJECT_LIKE
An object-like macro definition.
@ PP_MACRO_DIRECTIVE_HISTORY
The macro directives history for a particular identifier.
@ PP_MODULE_MACRO
A macro directive exported by a module.
ControlRecordTypes
Record types that occur within the control block.
@ MODULE_MAP_FILE
Record code for the module map file that was used to build this AST file.
@ MODULE_DIRECTORY
Record code for the module build directory.
@ IMPORTS
Record code for the list of other AST files imported by this AST file.
@ ORIGINAL_FILE_ID
Record code for file ID of the file or buffer that was used to generate the AST file.
@ MODULE_NAME
Record code for the module name.
@ ORIGINAL_FILE
Record code for the original file that was used to generate the AST file, including both its file ID ...
@ INPUT_FILE_OFFSETS
Offsets into the input-files block where input files reside.
@ METADATA
AST file metadata, including the AST file version number and information about the compiler used to b...
UnhashedControlBlockRecordTypes
Record codes for the unhashed control block.
@ DIAGNOSTIC_OPTIONS
Record code for the diagnostic options table.
@ HEADER_SEARCH_ENTRY_USAGE
Record code for the indices of used header search entries.
@ AST_BLOCK_HASH
Record code for the content hash of the AST block.
@ DIAG_PRAGMA_MAPPINGS
Record code for #pragma diagnostic mappings.
@ SIGNATURE
Record code for the signature that identifiers this AST file.
@ HEADER_SEARCH_PATHS
Record code for the headers search paths.
@ VFS_USAGE
Record code for the indices of used VFSs.
InputFileRecordTypes
Record types that occur within the input-files block inside the control block.
@ INPUT_FILE_HASH
The input file content hash.
@ INPUT_FILE
An input file.
PreprocessorDetailRecordTypes
Record types used within a preprocessor detail block.
@ PPD_INCLUSION_DIRECTIVE
Describes an inclusion directive within the preprocessing record.
@ PPD_MACRO_EXPANSION
Describes a macro expansion within the preprocessing record.
@ PPD_MACRO_DEFINITION
Describes a macro definition within the preprocessing record.
ModuleKind
Specifies the kind of module that has been loaded.
@ MK_PCH
File is a PCH file treated as such.
@ MK_Preamble
File is a PCH file treated as the preamble.
@ MK_MainFile
File is a PCH file treated as the actual main file.
@ MK_ExplicitModule
File is an explicitly-loaded module.
@ MK_ImplicitModule
File is an implicitly-loaded module.
@ MK_PrebuiltModule
File is from a prebuilt module path.
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
ASTRecordTypes
Record types that occur within the AST block itself.
@ DECL_UPDATE_OFFSETS
Record for offsets of DECL_UPDATES records for declarations that were modified after being deserializ...
@ STATISTICS
Record code for the extra statistics we gather while generating an AST file.
@ FLOAT_CONTROL_PRAGMA_OPTIONS
Record code for #pragma float_control options.
@ KNOWN_NAMESPACES
Record code for the set of known namespaces, which are used for typo correction.
@ SPECIAL_TYPES
Record code for the set of non-builtin, special types.
@ PENDING_IMPLICIT_INSTANTIATIONS
Record code for pending implicit instantiations.
@ TYPE_OFFSET
Record code for the offsets of each type.
@ DELEGATING_CTORS
The list of delegating constructor declarations.
@ PP_ASSUME_NONNULL_LOC
ID 66 used to be the list of included files.
@ EXT_VECTOR_DECLS
Record code for the set of ext_vector type names.
@ OPENCL_EXTENSIONS
Record code for enabled OpenCL extensions.
@ FP_PRAGMA_OPTIONS
Record code for floating point #pragma options.
@ VTABLE_USES
Record code for the array of VTable uses.
@ LATE_PARSED_TEMPLATE
Record code for late parsed template functions.
@ DECLS_TO_CHECK_FOR_DEFERRED_DIAGS
Record code for the Decls to be checked for deferred diags.
@ DECL_OFFSET
Record code for the offsets of each decl.
@ SOURCE_MANAGER_LINE_TABLE
Record code for the source manager line table information, which stores information about #line direc...
@ PP_COUNTER_VALUE
The value of the next COUNTER to dispense.
@ DELETE_EXPRS_TO_ANALYZE
Delete expressions that will be analyzed later.
@ UPDATE_VISIBLE
Record code for an update to a decl context's lookup table.
@ CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH
Number of unmatched #pragma clang cuda_force_host_device begin directives we've seen.
@ MACRO_OFFSET
Record code for the table of offsets of each macro ID.
@ PPD_ENTITIES_OFFSETS
Record code for the table of offsets to entries in the preprocessing record.
@ IDENTIFIER_OFFSET
Record code for the table of offsets of each identifier ID.
@ OBJC_CATEGORIES
Record code for the array of Objective-C categories (including extensions).
@ METHOD_POOL
Record code for the Objective-C method pool,.
@ DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD
Record code for lexical and visible block for delayed namespace in reduced BMI.
@ PP_CONDITIONAL_STACK
The stack of open #ifs/#ifdefs recorded in a preamble.
@ REFERENCED_SELECTOR_POOL
Record code for referenced selector pool.
@ SOURCE_LOCATION_OFFSETS
Record code for the table of offsets into the block of source-location information.
@ WEAK_UNDECLARED_IDENTIFIERS
Record code for weak undeclared identifiers.
@ UNDEFINED_BUT_USED
Record code for undefined but used functions and variables that need a definition in this TU.
@ FILE_SORTED_DECLS
Record code for a file sorted array of DeclIDs in a module.
@ MSSTRUCT_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
@ TENTATIVE_DEFINITIONS
Record code for the array of tentative definitions.
@ UNUSED_FILESCOPED_DECLS
Record code for the array of unused file scoped decls.
@ ALIGN_PACK_PRAGMA_OPTIONS
Record code for #pragma align/pack options.
@ IMPORTED_MODULES
Record code for an array of all of the (sub)modules that were imported by the AST file.
@ SELECTOR_OFFSETS
Record code for the table of offsets into the Objective-C method pool.
@ UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES
Record code for potentially unused local typedef names.
@ EAGERLY_DESERIALIZED_DECLS
Record code for the array of eagerly deserialized decls.
@ INTERESTING_IDENTIFIERS
A list of "interesting" identifiers.
@ HEADER_SEARCH_TABLE
Record code for header search information.
@ OBJC_CATEGORIES_MAP
Record code for map of Objective-C class definition IDs to the ObjC categories in a module that are a...
@ CUDA_SPECIAL_DECL_REFS
Record code for special CUDA declarations.
@ TU_UPDATE_LEXICAL
Record code for an update to the TU's lexically contained declarations.
@ PPD_SKIPPED_RANGES
A table of skipped ranges within the preprocessing record.
@ IDENTIFIER_TABLE
Record code for the identifier table.
@ SEMA_DECL_REFS
Record code for declarations that Sema keeps references of.
@ OPTIMIZE_PRAGMA_OPTIONS
Record code for #pragma optimize options.
@ MODULE_OFFSET_MAP
Record code for the remapping information used to relate loaded modules to the various offsets and ID...
@ POINTERS_TO_MEMBERS_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
uint32_t MacroID
An ID number that refers to a macro in an AST file.
uint32_t IdentifierID
An ID number that refers to an identifier in an AST file.
unsigned ComputeHash(Selector Sel)
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
OpenACCClauseKind
Represents the kind of an OpenACC clause.
@ Auto
'auto' clause, allowed on 'loop' directives.
@ Bind
'bind' clause, allowed on routine constructs.
@ Gang
'gang' clause, allowed on 'loop' and Combined constructs.
@ Wait
'wait' clause, allowed on Compute, Data, 'update', and Combined constructs.
@ DevicePtr
'deviceptr' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ PCopyOut
'copyout' clause alias 'pcopyout'. Preserved for diagnostic purposes.
@ VectorLength
'vector_length' clause, allowed on 'parallel', 'kernels', 'parallel loop', and 'kernels loop' constru...
@ Async
'async' clause, allowed on Compute, Data, 'update', 'wait', and Combined constructs.
@ PresentOrCreate
'create' clause alias 'present_or_create'.
@ Collapse
'collapse' clause, allowed on 'loop' and Combined constructs.
@ NoHost
'nohost' clause, allowed on 'routine' directives.
@ PresentOrCopy
'copy' clause alias 'present_or_copy'. Preserved for diagnostic purposes.
@ DeviceNum
'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
@ Invalid
Represents an invalid clause, for the purposes of parsing.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Copy
'copy' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ Worker
'worker' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ DeviceType
'device_type' clause, allowed on Compute, 'data', 'init', 'shutdown', 'set', update',...
@ DefaultAsync
'default_async' clause, allowed on 'set' construct.
@ Attach
'attach' clause, allowed on Compute and Combined constructs, plus 'data' and 'enter data'.
@ NumGangs
'num_gangs' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs.
@ If
'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...
@ Default
'default' clause, allowed on parallel, serial, kernel (and compound) constructs.
@ UseDevice
'use_device' clause, allowed on 'host_data' construct.
@ NoCreate
'no_create' clause, allowed on allowed on Compute and Combined constructs, plus 'data'.
@ PresentOrCopyOut
'copyout' clause alias 'present_or_copyout'.
@ Link
'link' clause, allowed on 'declare' construct.
@ Reduction
'reduction' clause, allowed on Parallel, Serial, Loop, and the combined constructs.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ CopyOut
'copyout' clause, allowed on Compute and Combined constructs, plus 'data', 'exit data',...
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ FirstPrivate
'firstprivate' clause, allowed on 'parallel', 'serial', 'parallel loop', and 'serial loop' constructs...
@ Host
'host' clause, allowed on 'update' construct.
@ PCopy
'copy' clause alias 'pcopy'. Preserved for diagnostic purposes.
@ Tile
'tile' clause, allowed on 'loop' and Combined constructs.
@ PCopyIn
'copyin' clause alias 'pcopyin'. Preserved for diagnostic purposes.
@ DeviceResident
'device_resident' clause, allowed on the 'declare' construct.
@ PCreate
'create' clause alias 'pcreate'. Preserved for diagnostic purposes.
@ Present
'present' clause, allowed on Compute and Combined constructs, plus 'data' and 'declare'.
@ DType
'dtype' clause, an alias for 'device_type', stored separately for diagnostic purposes.
@ CopyIn
'copyin' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ Device
'device' clause, allowed on the 'update' construct.
@ Independent
'independent' clause, allowed on 'loop' directives.
@ NumWorkers
'num_workers' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs...
@ IfPresent
'if_present' clause, allowed on 'host_data' and 'update' directives.
@ Detach
'detach' clause, allowed on the 'exit data' construct.
@ Delete
'delete' clause, allowed on the 'exit data' construct.
@ PresentOrCopyIn
'copyin' clause alias 'present_or_copyin'.
@ Finalize
'finalize' clause, allowed on 'exit data' directive.
TypeSpecifierType
Specifies the kind of type.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
OpenMPDefaultmapClauseModifier
OpenMP modifiers for 'defaultmap' clause.
OpenMPOrderClauseModifier
OpenMP modifiers for 'order' clause.
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
OpenMPAtClauseKind
OpenMP attributes for 'at' clause.
OpenMPReductionClauseModifier
OpenMP modifiers for 'reduction' clause.
OpenMPScheduleClauseModifier
OpenMP modifiers for 'schedule' clause.
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
OpenMPDoacrossClauseModifier
OpenMP dependence types for 'doacross' clause.
static constexpr unsigned NumberOfOMPMapClauseModifiers
Number of allowed map-type-modifiers.
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
PredefinedDeclIDs
Predefined declaration IDs.
@ PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID
The internal '__NSConstantString' tag type.
@ PREDEF_DECL_TRANSLATION_UNIT_ID
The translation unit.
@ PREDEF_DECL_TYPE_PACK_ELEMENT_ID
The internal '__type_pack_element' template.
@ PREDEF_DECL_OBJC_CLASS_ID
The Objective-C 'Class' type.
@ PREDEF_DECL_BUILTIN_MS_GUID_ID
The predeclared '_GUID' struct.
@ PREDEF_DECL_OBJC_INSTANCETYPE_ID
The internal 'instancetype' typedef.
@ PREDEF_DECL_OBJC_PROTOCOL_ID
The Objective-C 'Protocol' type.
@ PREDEF_DECL_UNSIGNED_INT_128_ID
The unsigned 128-bit integer type.
@ PREDEF_DECL_OBJC_SEL_ID
The Objective-C 'SEL' type.
@ PREDEF_DECL_INT_128_ID
The signed 128-bit integer type.
@ PREDEF_DECL_VA_LIST_TAG
The internal '__va_list_tag' struct, if any.
@ PREDEF_DECL_BUILTIN_MS_VA_LIST_ID
The internal '__builtin_ms_va_list' typedef.
@ PREDEF_DECL_CF_CONSTANT_STRING_ID
The internal '__NSConstantString' typedef.
@ PREDEF_DECL_NULL_ID
The NULL declaration.
@ PREDEF_DECL_BUILTIN_VA_LIST_ID
The internal '__builtin_va_list' typedef.
@ PREDEF_DECL_EXTERN_C_CONTEXT_ID
The extern "C" context.
@ PREDEF_DECL_OBJC_ID_ID
The Objective-C 'id' type.
@ PREDEF_DECL_MAKE_INTEGER_SEQ_ID
The internal '__make_integer_seq' template.
@ Property
The type of a property.
@ Result
The result type of a method or function.
OpenMPBindClauseKind
OpenMP bindings for the 'bind' clause.
OpenMPLastprivateModifier
OpenMP 'lastprivate' clause modifier.
OpenMPDependClauseKind
OpenMP attributes for 'depend' clause.
OpenMPGrainsizeClauseModifier
OpenMPNumTasksClauseModifier
OpenMPSeverityClauseKind
OpenMP attributes for 'severity' clause.
static constexpr unsigned NumberOfOMPMotionModifiers
Number of allowed motion-modifiers.
TypeSpecifierWidth
Specifies the width of a type, e.g., short, long, or long long.
OpenMPMotionModifierKind
OpenMP modifier kind for 'to' or 'from' clause.
OpenMPDefaultmapClauseKind
OpenMP attributes for 'defaultmap' clause.
OpenMPLinearClauseKind
OpenMP attributes for 'linear' clause.
TypeSpecifierSign
Specifies the signedness of a type, e.g., signed or unsigned.
llvm::hash_code hash_value(const CustomizableOptional< T > &O)
const FunctionProtoType * T
DisableValidationForModuleKind
Whether to disable the normal validation performed on precompiled headers and module files when they ...
@ None
Perform validation, don't disable it.
@ PCH
Disable validation for a precompiled header and the modules it depends on.
@ Module
Disable validation for module files.
bool shouldSkipCheckingODR(const Decl *D)
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
OpenMPAtomicDefaultMemOrderClauseKind
OpenMP attributes for 'atomic_default_mem_order' clause.
@ Success
Template argument deduction was successful.
U cast(CodeGen::Address addr)
@ None
The alignment was not explicit in code.
OpenMPDeviceClauseModifier
OpenMP modifiers for 'device' clause.
OpenMPMapModifierKind
OpenMP modifier kind for 'map' clause.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
OpenMPOrderClauseKind
OpenMP attributes for 'order' clause.
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
OpenMPMapClauseKind
OpenMP mapping kind for 'map' clause.
The signature of a module, which is a hash of the AST content.
static constexpr size_t size
static ASTFileSignature create(std::array< uint8_t, 20 > Bytes)
static ASTFileSignature createDummy()
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
void setInfo(const DeclarationNameLoc &Info)
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
A simple structure that captures a vtable use for the purposes of the ExternalSemaSource.
ExceptionSpecInfo ExceptionSpec
static LineEntry get(unsigned Offs, unsigned Line, int Filename, SrcMgr::CharacteristicKind FileKind, unsigned IncludeOffset)
A conflict between two modules.
Module * Other
The module that this module conflicts with.
std::string Message
The message provided to the user when there is a conflict.
A library or framework to link against when an entity from this module is used.
This structure contains all sizes needed for by an OMPMappableExprListClause.
unsigned NumComponentLists
Number of component lists.
unsigned NumVars
Number of expressions listed.
unsigned NumUniqueDeclarations
Number of unique base declarations.
unsigned NumComponents
Total number of expression components.
Data for list of allocators.
SourceLocation LParenLoc
Locations of '(' and ')' symbols.
Expr * AllocatorTraits
Allocator traits.
Expr * Allocator
Allocator.
a linked list of methods with the same selector name but different signatures.
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
TemplateParameterList ** TemplParamLists
A new-allocated array of size NumTemplParamLists, containing pointers to the "outer" template paramet...
NestedNameSpecifierLoc QualifierLoc
unsigned NumTemplParamLists
The number of "outer" template parameter lists.
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
SanitizerMask Mask
Bitmask of enabled sanitizers.
Helper class that saves the current stream position and then restores it when destroyed.
PragmaMsStackAction Action
Location information for a TemplateArgument.
Describes the categories of an Objective-C class.
void insert(GlobalDeclID ID)