93#include "llvm/ADT/APFloat.h"
94#include "llvm/ADT/APInt.h"
95#include "llvm/ADT/APSInt.h"
96#include "llvm/ADT/ArrayRef.h"
97#include "llvm/ADT/DenseMap.h"
98#include "llvm/ADT/FloatingPointMode.h"
99#include "llvm/ADT/FoldingSet.h"
100#include "llvm/ADT/Hashing.h"
101#include "llvm/ADT/IntrusiveRefCntPtr.h"
102#include "llvm/ADT/STLExtras.h"
103#include "llvm/ADT/ScopeExit.h"
104#include "llvm/ADT/SmallPtrSet.h"
105#include "llvm/ADT/SmallString.h"
106#include "llvm/ADT/SmallVector.h"
107#include "llvm/ADT/StringExtras.h"
108#include "llvm/ADT/StringMap.h"
109#include "llvm/ADT/StringRef.h"
110#include "llvm/ADT/iterator_range.h"
111#include "llvm/Bitstream/BitstreamReader.h"
112#include "llvm/Support/Casting.h"
113#include "llvm/Support/Compiler.h"
114#include "llvm/Support/Compression.h"
115#include "llvm/Support/DJB.h"
116#include "llvm/Support/Endian.h"
117#include "llvm/Support/Error.h"
118#include "llvm/Support/ErrorHandling.h"
119#include "llvm/Support/FileSystem.h"
120#include "llvm/Support/LEB128.h"
121#include "llvm/Support/MemoryBuffer.h"
122#include "llvm/Support/Path.h"
123#include "llvm/Support/SaveAndRestore.h"
124#include "llvm/Support/TimeProfiler.h"
125#include "llvm/Support/Timer.h"
126#include "llvm/Support/VersionTuple.h"
127#include "llvm/Support/raw_ostream.h"
128#include "llvm/TargetParser/Triple.h"
141#include <system_error>
146using namespace clang;
149using llvm::BitstreamCursor;
157 return First->ReadFullVersionInformation(FullVersion) ||
158 Second->ReadFullVersionInformation(FullVersion);
162 First->ReadModuleName(ModuleName);
163 Second->ReadModuleName(ModuleName);
167 First->ReadModuleMapFile(ModuleMapPath);
168 Second->ReadModuleMapFile(ModuleMapPath);
174 bool AllowCompatibleDifferences) {
175 return First->ReadLanguageOptions(LangOpts, Complain,
176 AllowCompatibleDifferences) ||
177 Second->ReadLanguageOptions(LangOpts, Complain,
178 AllowCompatibleDifferences);
183 bool AllowCompatibleDifferences) {
184 return First->ReadTargetOptions(TargetOpts, Complain,
185 AllowCompatibleDifferences) ||
186 Second->ReadTargetOptions(TargetOpts, Complain,
187 AllowCompatibleDifferences);
192 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
193 Second->ReadDiagnosticOptions(DiagOpts, Complain);
199 return First->ReadFileSystemOptions(FSOpts, Complain) ||
200 Second->ReadFileSystemOptions(FSOpts, Complain);
206 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
208 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
214 std::string &SuggestedPredefines) {
215 return First->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
216 SuggestedPredefines) ||
217 Second->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
218 SuggestedPredefines);
223 First->ReadCounter(M,
Value);
224 Second->ReadCounter(M,
Value);
228 return First->needsInputFileVisitation() ||
229 Second->needsInputFileVisitation();
233 return First->needsSystemInputFileVisitation() ||
234 Second->needsSystemInputFileVisitation();
239 First->visitModuleFile(
Filename, Kind);
240 Second->visitModuleFile(
Filename, Kind);
246 bool isExplicitModule) {
247 bool Continue =
false;
248 if (First->needsInputFileVisitation() &&
249 (!isSystem || First->needsSystemInputFileVisitation()))
250 Continue |= First->visitInputFile(
Filename, isSystem, isOverridden,
252 if (Second->needsInputFileVisitation() &&
253 (!isSystem || Second->needsSystemInputFileVisitation()))
254 Continue |= Second->visitInputFile(
Filename, isSystem, isOverridden,
261 First->readModuleFileExtension(Metadata);
262 Second->readModuleFileExtension(Metadata);
282 bool AllowCompatibleDifferences =
true) {
283#define LANGOPT(Name, Bits, Default, Description) \
284 if (ExistingLangOpts.Name != LangOpts.Name) { \
287 Diags->Report(diag::err_pch_langopt_mismatch) \
288 << Description << LangOpts.Name << ExistingLangOpts.Name; \
290 Diags->Report(diag::err_pch_langopt_value_mismatch) \
296#define VALUE_LANGOPT(Name, Bits, Default, Description) \
297 if (ExistingLangOpts.Name != LangOpts.Name) { \
299 Diags->Report(diag::err_pch_langopt_value_mismatch) \
304#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
305 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
307 Diags->Report(diag::err_pch_langopt_value_mismatch) \
312#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
313 if (!AllowCompatibleDifferences) \
314 LANGOPT(Name, Bits, Default, Description)
316#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
317 if (!AllowCompatibleDifferences) \
318 ENUM_LANGOPT(Name, Bits, Default, Description)
320#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
321 if (!AllowCompatibleDifferences) \
322 VALUE_LANGOPT(Name, Bits, Default, Description)
324#define BENIGN_LANGOPT(Name, Bits, Default, Description)
325#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
326#define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description)
327#include "clang/Basic/LangOptions.def"
331 Diags->
Report(diag::err_pch_langopt_value_mismatch) <<
"module features";
337 Diags->
Report(diag::err_pch_langopt_value_mismatch)
338 <<
"target Objective-C runtime";
345 Diags->
Report(diag::err_pch_langopt_value_mismatch)
346 <<
"block command names";
354 if (!AllowCompatibleDifferences) {
358 ExistingSanitizers.
clear(ModularSanitizers);
359 ImportedSanitizers.
clear(ModularSanitizers);
360 if (ExistingSanitizers.
Mask != ImportedSanitizers.
Mask) {
361 const std::string Flag =
"-fsanitize=";
363#define SANITIZER(NAME, ID) \
365 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
366 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
367 if (InExistingModule != InImportedModule) \
368 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
369 << InExistingModule << (Flag + NAME); \
371#include "clang/Basic/Sanitizers.def"
389 bool AllowCompatibleDifferences =
true) {
390#define CHECK_TARGET_OPT(Field, Name) \
391 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
393 Diags->Report(diag::err_pch_targetopt_mismatch) \
394 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
405 if (!AllowCompatibleDifferences) {
410#undef CHECK_TARGET_OPT
418 llvm::sort(ExistingFeatures);
419 llvm::sort(ReadFeatures);
425 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
426 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
427 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
428 ExistingFeatures.begin(), ExistingFeatures.end(),
429 std::back_inserter(UnmatchedReadFeatures));
433 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
437 for (StringRef Feature : UnmatchedReadFeatures)
438 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
440 for (StringRef Feature : UnmatchedExistingFeatures)
441 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
445 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
451 bool AllowCompatibleDifferences) {
454 Complain ? &Reader.Diags :
nullptr,
455 AllowCompatibleDifferences);
460 bool AllowCompatibleDifferences) {
463 Complain ? &Reader.Diags :
nullptr,
464 AllowCompatibleDifferences);
469using MacroDefinitionsMap =
470 llvm::StringMap<std::pair<StringRef,
bool >>;
471using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
486 for (
auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
495 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror=" +
514 bool SystemHeaderWarningsInModule,
523 !SystemHeaderWarningsInModule) {
525 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Wsystem-headers";
532 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror";
539 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Weverything -Werror";
546 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-pedantic-errors";
570 assert(!ModuleName.empty() &&
"diagnostic options read before module name");
574 assert(M &&
"missing module");
589 assert(ModuleMgr.
size() >= 1 &&
"what ASTFile is this then");
598 bool SystemHeaderWarningsInModule =
605 SystemHeaderWarningsInModule, Complain);
612 MacroDefinitionsMap &Macros,
614 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
615 StringRef Macro = PPOpts.
Macros[I].first;
616 bool IsUndef = PPOpts.
Macros[I].second;
618 std::pair<StringRef, StringRef> MacroPair = Macro.split(
'=');
619 StringRef MacroName = MacroPair.first;
620 StringRef MacroBody = MacroPair.second;
624 if (MacroNames && !Macros.count(MacroName))
625 MacroNames->push_back(MacroName);
627 Macros[MacroName] = std::make_pair(
"",
true);
632 if (MacroName.size() == Macro.size())
636 StringRef::size_type End = MacroBody.find_first_of(
"\n\r");
637 MacroBody = MacroBody.substr(0, End);
640 if (MacroNames && !Macros.count(MacroName))
641 MacroNames->push_back(MacroName);
642 Macros[MacroName] = std::make_pair(MacroBody,
false);
666 std::string &SuggestedPredefines,
const LangOptions &LangOpts,
670 MacroDefinitionsMap ASTFileMacros;
672 MacroDefinitionsMap ExistingMacros;
675 &ExistingMacroNames);
679 SuggestedPredefines +=
"# 1 \"<command line>\" 1\n";
681 for (
unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
683 StringRef MacroName = ExistingMacroNames[I];
684 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
687 llvm::StringMap<std::pair<StringRef,
bool >>::iterator Known =
688 ASTFileMacros.find(MacroName);
694 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
true;
702 if (Existing.second) {
703 SuggestedPredefines +=
"#undef ";
704 SuggestedPredefines += MacroName.str();
705 SuggestedPredefines +=
'\n';
707 SuggestedPredefines +=
"#define ";
708 SuggestedPredefines += MacroName.str();
709 SuggestedPredefines +=
' ';
710 SuggestedPredefines += Existing.first.str();
711 SuggestedPredefines +=
'\n';
718 if (Existing.second != Known->second.second) {
720 Diags->
Report(diag::err_pch_macro_def_undef)
721 << MacroName << Known->second.second;
728 if (Existing.second || Existing.first == Known->second.first) {
729 ASTFileMacros.erase(Known);
735 Diags->
Report(diag::err_pch_macro_def_conflict)
736 << MacroName << Known->second.first << Existing.first;
742 SuggestedPredefines +=
"# 1 \"<built-in>\" 2\n";
747 for (
const auto &MacroName : ASTFileMacros.keys()) {
749 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
false;
766 if (LangOpts.Modules &&
776 for (
unsigned I = 0, N = ExistingPPOpts.
Includes.size(); I != N; ++I) {
783 SuggestedPredefines +=
"#include \"";
784 SuggestedPredefines +=
File;
785 SuggestedPredefines +=
"\"\n";
795 SuggestedPredefines +=
"#include \"";
796 SuggestedPredefines +=
File;
797 SuggestedPredefines +=
"\"\n";
800 for (
unsigned I = 0, N = ExistingPPOpts.
MacroIncludes.size(); I != N; ++I) {
805 SuggestedPredefines +=
"#__include_macros \"";
806 SuggestedPredefines +=
File;
807 SuggestedPredefines +=
"\"\n##\n";
814 bool ReadMacros,
bool Complain,
815 std::string &SuggestedPredefines) {
819 PPOpts, ExistingPPOpts, ReadMacros, Complain ? &Reader.Diags :
nullptr,
825 std::string &SuggestedPredefines) {
837 StringRef SpecificModuleCachePath,
838 StringRef ExistingModuleCachePath,
842 if (LangOpts.Modules) {
843 if (SpecificModuleCachePath != ExistingModuleCachePath &&
846 Diags->
Report(diag::err_pch_modulecache_mismatch)
847 << SpecificModuleCachePath << ExistingModuleCachePath;
856 StringRef SpecificModuleCachePath,
860 Complain ? &Reader.Diags :
nullptr,
874 const char *Error =
nullptr;
876 uint64_t Val = llvm::decodeULEB128(
P, &Length,
nullptr, &Error);
878 llvm::report_fatal_error(Error);
884static std::pair<unsigned, unsigned>
887 if ((
unsigned)KeyLen != KeyLen)
888 llvm::report_fatal_error(
"key too large");
891 if ((
unsigned)DataLen != DataLen)
892 llvm::report_fatal_error(
"data too large");
894 return std::make_pair(KeyLen, DataLen);
898 bool TakeOwnership) {
899 DeserializationListener = Listener;
900 OwnsDeserializationListener = TakeOwnership;
907std::pair<unsigned, unsigned>
914 using namespace llvm::support;
917 unsigned N = endian::readNext<uint16_t, llvm::endianness::little>(d);
919 F, endian::readNext<uint32_t, llvm::endianness::little>(d));
926 Args.push_back(FirstII);
927 for (
unsigned I = 1; I != N; ++I)
928 Args.push_back(Reader.getLocalIdentifier(
929 F, endian::readNext<uint32_t, llvm::endianness::little>(d)));
937 using namespace llvm::support;
941 Result.ID = Reader.getGlobalSelectorID(
942 F, endian::readNext<uint32_t, llvm::endianness::little>(d));
943 unsigned FullInstanceBits =
944 endian::readNext<uint16_t, llvm::endianness::little>(d);
945 unsigned FullFactoryBits =
946 endian::readNext<uint16_t, llvm::endianness::little>(d);
947 Result.InstanceBits = FullInstanceBits & 0x3;
948 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
949 Result.FactoryBits = FullFactoryBits & 0x3;
950 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
951 unsigned NumInstanceMethods = FullInstanceBits >> 3;
952 unsigned NumFactoryMethods = FullFactoryBits >> 3;
955 for (
unsigned I = 0; I != NumInstanceMethods; ++I) {
958 LocalDeclID(endian::readNext<DeclID, llvm::endianness::little>(d))))
959 Result.Instance.push_back(Method);
963 for (
unsigned I = 0; I != NumFactoryMethods; ++I) {
966 LocalDeclID(endian::readNext<DeclID, llvm::endianness::little>(d))))
967 Result.Factory.push_back(Method);
974 return llvm::djbHash(a);
977std::pair<unsigned, unsigned>
984 assert(n >= 2 && d[n-1] ==
'\0');
985 return StringRef((
const char*) d, n-1);
1002 bool Value = Bits & 0x1;
1008 using namespace llvm::support;
1010 unsigned RawID = endian::readNext<uint32_t, llvm::endianness::little>(d);
1011 return Reader.getGlobalIdentifierID(F, RawID >> 1);
1024 const unsigned char* d,
1026 using namespace llvm::support;
1028 unsigned RawID = endian::readNext<uint32_t, llvm::endianness::little>(d);
1029 bool IsInteresting = RawID & 0x01;
1037 II = &Reader.getIdentifierTable().getOwn(k);
1041 Reader.markIdentifierUpToDate(II);
1043 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
1044 if (!IsInteresting) {
1047 Reader.SetIdentifierInfo(ID, II);
1051 unsigned ObjCOrBuiltinID =
1052 endian::readNext<uint16_t, llvm::endianness::little>(d);
1053 unsigned Bits = endian::readNext<uint16_t, llvm::endianness::little>(d);
1054 bool CPlusPlusOperatorKeyword =
readBit(Bits);
1055 bool HasRevertedTokenIDToIdentifier =
readBit(Bits);
1056 bool Poisoned =
readBit(Bits);
1057 bool ExtensionToken =
readBit(Bits);
1058 bool HadMacroDefinition =
readBit(Bits);
1060 assert(Bits == 0 &&
"Extra bits in the identifier?");
1065 if (HasRevertedTokenIDToIdentifier && II->
getTokenID() != tok::identifier)
1070 "Incorrect extension token flag");
1071 (void)ExtensionToken;
1075 "Incorrect C++ operator keyword flag");
1076 (void)CPlusPlusOperatorKeyword;
1080 if (HadMacroDefinition) {
1081 uint32_t MacroDirectivesOffset =
1082 endian::readNext<uint32_t, llvm::endianness::little>(d);
1085 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1088 Reader.SetIdentifierInfo(ID, II);
1094 for (; DataLen > 0; DataLen -=
sizeof(
DeclID))
1095 DeclIDs.push_back(Reader.getGlobalDeclID(
1097 LocalDeclID(endian::readNext<DeclID, llvm::endianness::little>(d))));
1098 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1105 : Kind(Name.getNameKind()) {
1108 Data = (uint64_t)Name.getAsIdentifierInfo();
1113 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1116 Data = Name.getCXXOverloadedOperator();
1119 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1122 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1123 ->getDeclName().getAsIdentifierInfo();
1135 llvm::FoldingSetNodeID ID;
1136 ID.AddInteger(Kind);
1159 return ID.ComputeHash();
1163ASTDeclContextNameLookupTrait::ReadFileRef(
const unsigned char *&d) {
1164 using namespace llvm::support;
1166 uint32_t ModuleFileID =
1167 endian::readNext<uint32_t, llvm::endianness::little>(d);
1168 return Reader.getLocalModuleFile(F, ModuleFileID);
1171std::pair<unsigned, unsigned>
1172ASTDeclContextNameLookupTrait::ReadKeyDataLength(
const unsigned char *&d) {
1177ASTDeclContextNameLookupTrait::ReadKey(
const unsigned char *d,
unsigned) {
1178 using namespace llvm::support;
1186 Data = (uint64_t)Reader.getLocalIdentifier(
1187 F, endian::readNext<uint32_t, llvm::endianness::little>(d));
1192 Data = (uint64_t)Reader
1194 F, endian::readNext<uint32_t, llvm::endianness::little>(d))
1212 const unsigned char *d,
1215 using namespace llvm::support;
1217 for (
unsigned NumDecls = DataLen /
sizeof(
DeclID); NumDecls; --NumDecls) {
1218 LocalDeclID LocalID(endian::readNext<DeclID, llvm::endianness::little>(d));
1219 Val.
insert(Reader.getGlobalDeclID(F, LocalID));
1223bool ASTReader::ReadLexicalDeclContextStorage(
ModuleFile &M,
1224 BitstreamCursor &Cursor,
1227 assert(Offset != 0);
1230 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1231 Error(std::move(Err));
1239 Error(MaybeCode.takeError());
1242 unsigned Code = MaybeCode.get();
1245 if (!MaybeRecCode) {
1246 Error(MaybeRecCode.takeError());
1249 unsigned RecCode = MaybeRecCode.get();
1251 Error(
"Expected lexical block");
1255 assert(!isa<TranslationUnitDecl>(DC) &&
1256 "expected a TU_UPDATE_LEXICAL record for TU");
1261 auto &Lex = LexicalDecls[DC];
1263 Lex = std::make_pair(
1265 reinterpret_cast<const unalighed_decl_id_t *
>(Blob.data()),
1266 Blob.size() /
sizeof(
DeclID)));
1272bool ASTReader::ReadVisibleDeclContextStorage(
ModuleFile &M,
1273 BitstreamCursor &Cursor,
1276 assert(Offset != 0);
1279 if (llvm::Error Err =
Cursor.JumpToBit(Offset)) {
1280 Error(std::move(Err));
1288 Error(MaybeCode.takeError());
1291 unsigned Code = MaybeCode.get();
1294 if (!MaybeRecCode) {
1295 Error(MaybeRecCode.takeError());
1298 unsigned RecCode = MaybeRecCode.get();
1300 Error(
"Expected visible lookup table block");
1306 auto *
Data = (
const unsigned char*)Blob.data();
1307 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&M,
Data});
1311void ASTReader::Error(StringRef Msg)
const {
1312 Error(diag::err_fe_pch_malformed, Msg);
1313 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1314 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1315 Diag(diag::note_module_cache_path)
1316 << PP.getHeaderSearchInfo().getModuleCachePath();
1320void ASTReader::Error(
unsigned DiagID, StringRef Arg1, StringRef Arg2,
1321 StringRef Arg3)
const {
1322 if (Diags.isDiagnosticInFlight())
1323 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1325 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1328void ASTReader::Error(llvm::Error &&Err)
const {
1329 llvm::Error RemainingErr =
1336 assert(NumArgs <= 3 &&
"Can only have up to 3 arguments");
1337 StringRef Arg1, Arg2, Arg3;
1340 Arg3 =
Diag.getStringArg(2);
1343 Arg2 =
Diag.getStringArg(1);
1346 Arg1 =
Diag.getStringArg(0);
1348 Error(
Diag.getDiagID(), Arg1, Arg2, Arg3);
1364 std::map<int, int> FileIDs;
1366 for (
unsigned I = 0;
Record[Idx]; ++I) {
1374 std::vector<LineEntry> Entries;
1375 while (Idx <
Record.size()) {
1379 unsigned NumEntries =
Record[Idx++];
1380 assert(NumEntries &&
"no line entries for file ID");
1382 Entries.reserve(NumEntries);
1383 for (
unsigned I = 0; I != NumEntries; ++I) {
1384 unsigned FileOffset =
Record[Idx++];
1385 unsigned LineNo =
Record[Idx++];
1386 int FilenameID = FileIDs[
Record[Idx++]];
1389 unsigned IncludeOffset =
Record[Idx++];
1391 FileKind, IncludeOffset));
1398llvm::Error ASTReader::ReadSourceManagerBlock(
ModuleFile &F) {
1399 using namespace SrcMgr;
1407 SLocEntryCursor = F.
Stream;
1410 if (llvm::Error Err = F.
Stream.SkipBlock())
1421 SLocEntryCursor.advanceSkippingSubblocks();
1423 return MaybeE.takeError();
1424 llvm::BitstreamEntry E = MaybeE.get();
1427 case llvm::BitstreamEntry::SubBlock:
1428 case llvm::BitstreamEntry::Error:
1429 return llvm::createStringError(std::errc::illegal_byte_sequence,
1430 "malformed block record in AST file");
1431 case llvm::BitstreamEntry::EndBlock:
1432 return llvm::Error::success();
1433 case llvm::BitstreamEntry::Record:
1442 SLocEntryCursor.readRecord(E.ID,
Record, &Blob);
1444 return MaybeRecord.takeError();
1445 switch (MaybeRecord.get()) {
1453 return llvm::Error::success();
1464 return std::move(Err);
1468 return MaybeEntry.takeError();
1470 llvm::BitstreamEntry Entry = MaybeEntry.get();
1471 if (Entry.Kind != llvm::BitstreamEntry::Record)
1472 return llvm::createStringError(
1473 std::errc::illegal_byte_sequence,
1474 "incorrectly-formatted source location entry in AST file");
1480 return MaybeSLOC.takeError();
1482 switch (MaybeSLOC.get()) {
1484 return llvm::createStringError(
1485 std::errc::illegal_byte_sequence,
1486 "incorrectly-formatted source location entry in AST file");
1496 GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - SLocOffset - 1);
1497 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
1498 "Corrupted global sloc offset map");
1503 auto It = llvm::upper_bound(
1506 int ID = F->SLocEntryBaseID + LocalIndex;
1507 std::size_t Index = -ID - 2;
1508 if (!SourceMgr.SLocEntryOffsetLoaded[Index]) {
1509 assert(!SourceMgr.SLocEntryLoaded[Index]);
1510 auto MaybeEntryOffset = readSLocOffset(F, LocalIndex);
1511 if (!MaybeEntryOffset) {
1512 Error(MaybeEntryOffset.takeError());
1516 SourceMgr.LoadedSLocEntryTable[Index] =
1517 SrcMgr::SLocEntry::getOffsetOnly(*MaybeEntryOffset);
1518 SourceMgr.SLocEntryOffsetLoaded[Index] = true;
1520 return Offset < SourceMgr.LoadedSLocEntryTable[Index].getOffset();
1535 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1536 Error(
"source location entry ID out-of-range for AST file");
1542 auto ReadBuffer = [
this](
1543 BitstreamCursor &SLocEntryCursor,
1544 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1549 Error(MaybeCode.takeError());
1552 unsigned Code = MaybeCode.get();
1555 SLocEntryCursor.readRecord(Code,
Record, &Blob);
1556 if (!MaybeRecCode) {
1557 Error(MaybeRecCode.takeError());
1560 unsigned RecCode = MaybeRecCode.get();
1565 const llvm::compression::Format F =
1566 Blob.size() > 0 && Blob.data()[0] == 0x78
1567 ? llvm::compression::Format::Zlib
1568 : llvm::compression::Format::Zstd;
1569 if (
const char *Reason = llvm::compression::getReasonIfUnsupported(F)) {
1574 if (llvm::Error E = llvm::compression::decompress(
1575 F, llvm::arrayRefFromStringRef(Blob), Decompressed,
Record[0])) {
1576 Error(
"could not decompress embedded file contents: " +
1577 llvm::toString(std::move(E)));
1580 return llvm::MemoryBuffer::getMemBufferCopy(
1581 llvm::toStringRef(Decompressed), Name);
1583 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name,
true);
1585 Error(
"AST record has invalid code");
1590 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1594 Error(std::move(Err));
1601 ++NumSLocEntriesRead;
1604 Error(MaybeEntry.takeError());
1607 llvm::BitstreamEntry Entry = MaybeEntry.get();
1609 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1610 Error(
"incorrectly-formatted source location entry in AST file");
1617 SLocEntryCursor.readRecord(Entry.ID,
Record, &Blob);
1619 Error(MaybeSLOC.takeError());
1622 switch (MaybeSLOC.get()) {
1624 Error(
"incorrectly-formatted source location entry in AST file");
1630 unsigned InputID =
Record[4];
1631 InputFile IF = getInputFile(*F, InputID);
1644 IncludeLoc = getImportLocation(F);
1648 FileID FID = SourceMgr.createFileID(*
File, IncludeLoc, FileCharacter, ID,
1652 FileInfo.NumCreatedFIDs =
Record[5];
1656 unsigned NumFileDecls =
Record[7];
1657 if (NumFileDecls && ContextObj) {
1659 assert(F->
FileSortedDecls &&
"FILE_SORTED_DECLS not encountered yet ?");
1665 SourceMgr.getOrCreateContentCache(*
File, isSystem(FileCharacter));
1669 auto Buffer = ReadBuffer(SLocEntryCursor,
File->getName());
1672 SourceMgr.overrideFileContents(*
File, std::move(Buffer));
1679 const char *Name = Blob.data();
1680 unsigned Offset =
Record[0];
1685 IncludeLoc = getImportLocation(F);
1688 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1691 FileID FID = SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1692 BaseOffset + Offset, IncludeLoc);
1706 SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
1720 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1721 Error(
"source location entry ID out-of-range for AST file");
1726 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1744 assert(SourceMgr.getMainFileID().isValid() &&
"missing main file");
1745 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1755 uint64_t *StartOfBlockOffset) {
1756 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID))
1759 if (StartOfBlockOffset)
1760 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1763 uint64_t Offset = Cursor.GetCurrentBitNo();
1766 return MaybeCode.takeError();
1767 unsigned Code = MaybeCode.get();
1770 if (Code != llvm::bitc::DEFINE_ABBREV) {
1771 if (llvm::Error Err = Cursor.JumpToBit(Offset))
1773 return llvm::Error::success();
1775 if (llvm::Error Err = Cursor.ReadAbbrevRecord())
1791 case tok::annot_pragma_loop_hint: {
1794 Info->Option = ReadToken(M,
Record, Idx);
1795 unsigned NumTokens =
Record[Idx++];
1797 Toks.reserve(NumTokens);
1798 for (
unsigned I = 0; I < NumTokens; ++I)
1799 Toks.push_back(ReadToken(M,
Record, Idx));
1800 Info->Toks =
llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
1804 case tok::annot_pragma_pack: {
1807 auto SlotLabel = ReadString(
Record, Idx);
1809 llvm::StringRef(SlotLabel).copy(PP.getPreprocessorAllocator());
1810 Info->Alignment = ReadToken(M,
Record, Idx);
1815 case tok::annot_pragma_openmp:
1816 case tok::annot_pragma_openmp_end:
1817 case tok::annot_pragma_unused:
1818 case tok::annot_pragma_openacc:
1819 case tok::annot_pragma_openacc_end:
1822 llvm_unreachable(
"missing deserialization code for annotation token");
1839 if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1841 consumeError(std::move(Err));
1853 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1855 Stream.advanceSkippingSubblocks(Flags);
1857 Error(MaybeEntry.takeError());
1860 llvm::BitstreamEntry Entry = MaybeEntry.get();
1862 switch (Entry.Kind) {
1863 case llvm::BitstreamEntry::SubBlock:
1864 case llvm::BitstreamEntry::Error:
1865 Error(
"malformed block record in AST file");
1867 case llvm::BitstreamEntry::EndBlock:
1869 case llvm::BitstreamEntry::Record:
1880 Error(MaybeRecType.takeError());
1896 unsigned NextIndex = 1;
1898 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1903 PP.getPreprocessorAllocator());
1906 bool isC99VarArgs =
Record[NextIndex++];
1907 bool isGNUVarArgs =
Record[NextIndex++];
1908 bool hasCommaPasting =
Record[NextIndex++];
1909 MacroParams.clear();
1910 unsigned NumArgs =
Record[NextIndex++];
1911 for (
unsigned i = 0; i != NumArgs; ++i)
1912 MacroParams.push_back(getLocalIdentifier(F,
Record[NextIndex++]));
1926 if (NextIndex + 1 ==
Record.size() && PP.getPreprocessingRecord() &&
1930 GlobalID = getGlobalPreprocessedEntityID(F,
Record[NextIndex]);
1932 PreprocessingRecord::PPEntityID PPID =
1933 PPRec.getPPEntityID(GlobalID - 1,
true);
1935 PPRec.getPreprocessedEntity(PPID));
1937 PPRec.RegisterMacroDefinition(Macro, PPDef);
1948 if (MacroTokens.empty()) {
1949 Error(
"unexpected number of macro tokens for a macro in AST file");
1954 MacroTokens[0] = ReadToken(F,
Record, Idx);
1955 MacroTokens = MacroTokens.drop_front();
1964 unsigned LocalID)
const {
1966 ReadModuleOffsetMap(M);
1971 &&
"Invalid index into preprocessed entity index remap");
1973 return LocalID + I->second;
1976const FileEntry *HeaderFileInfoTrait::getFile(
const internal_key_type &Key) {
1978 if (!Key.Imported) {
1984 std::string Resolved = std::string(Key.Filename);
1985 Reader.ResolveImportedPath(M, Resolved);
1992 return llvm::hash_combine(ikey.
Size, ikey.
ModTime);
2013 return FEA && FEA == FEB;
2016std::pair<unsigned, unsigned>
2017HeaderFileInfoTrait::ReadKeyDataLength(
const unsigned char*& d) {
2022HeaderFileInfoTrait::ReadKey(
const unsigned char *d,
unsigned) {
2023 using namespace llvm::support;
2026 ikey.
Size = off_t(endian::readNext<uint64_t, llvm::endianness::little>(d));
2028 time_t(endian::readNext<uint64_t, llvm::endianness::little>(d));
2037 using namespace llvm::support;
2039 const unsigned char *End = d + DataLen;
2041 unsigned Flags = *d++;
2043 bool Included = (Flags >> 6) & 0x01;
2048 Reader.getPreprocessor().getIncludedFiles().insert(FE);
2051 HFI.
isImport |= (Flags >> 5) & 0x01;
2053 HFI.
DirInfo = (Flags >> 1) & 0x07;
2056 M, endian::readNext<uint32_t, llvm::endianness::little>(d));
2057 if (
unsigned FrameworkOffset =
2058 endian::readNext<uint32_t, llvm::endianness::little>(d)) {
2061 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
2062 HFI.
Framework = HS->getUniqueFrameworkName(FrameworkName);
2065 assert((End - d) % 4 == 0 &&
2066 "Wrong data length in HeaderFileInfo deserialization");
2068 uint32_t LocalSMID =
2069 endian::readNext<uint32_t, llvm::endianness::little>(d);
2075 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
2076 Module *Mod = Reader.getSubmodule(GlobalSMID);
2079 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
2083 Reader.ResolveImportedPath(M,
Filename);
2087 ModMap.
addHeader(Mod, H, HeaderRole,
true);
2099 uint32_t MacroDirectivesOffset) {
2100 assert(NumCurrentElementsDeserializing > 0 &&
"Missing deserialization guard");
2101 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
2108 for (
ModuleFile &I : llvm::reverse(ModuleMgr)) {
2109 BitstreamCursor &MacroCursor = I.MacroCursor;
2112 if (MacroCursor.getBitcodeBytes().empty())
2115 BitstreamCursor Cursor = MacroCursor;
2116 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
2117 Error(std::move(Err));
2125 Error(MaybeE.takeError());
2128 llvm::BitstreamEntry E = MaybeE.get();
2131 case llvm::BitstreamEntry::SubBlock:
2132 case llvm::BitstreamEntry::Error:
2133 Error(
"malformed block record in AST file");
2135 case llvm::BitstreamEntry::EndBlock:
2138 case llvm::BitstreamEntry::Record: {
2142 Error(MaybeRecord.takeError());
2145 switch (MaybeRecord.get()) {
2153 updateOutOfDateIdentifier(*II);
2172 class IdentifierLookupVisitor {
2175 unsigned PriorGeneration;
2176 unsigned &NumIdentifierLookups;
2177 unsigned &NumIdentifierLookupHits;
2181 IdentifierLookupVisitor(StringRef Name,
unsigned PriorGeneration,
2182 unsigned &NumIdentifierLookups,
2183 unsigned &NumIdentifierLookupHits)
2185 PriorGeneration(PriorGeneration),
2186 NumIdentifierLookups(NumIdentifierLookups),
2187 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2201 ++NumIdentifierLookups;
2202 ASTIdentifierLookupTable::iterator Pos =
2203 IdTable->find_hashed(Name, NameHash, &Trait);
2204 if (Pos == IdTable->end())
2210 ++NumIdentifierLookupHits;
2226 unsigned PriorGeneration = 0;
2227 if (getContext().getLangOpts().Modules)
2228 PriorGeneration = IdentifierGeneration[&II];
2234 if (!loadGlobalIndex()) {
2235 if (GlobalIndex->lookupIdentifier(II.
getName(), Hits)) {
2240 IdentifierLookupVisitor Visitor(II.
getName(), PriorGeneration,
2241 NumIdentifierLookups,
2242 NumIdentifierLookupHits);
2243 ModuleMgr.visit(Visitor, HitsPtr);
2244 markIdentifierUpToDate(&II);
2254 if (getContext().getLangOpts().Modules)
2255 IdentifierGeneration[II] = getGeneration();
2259 const PendingMacroInfo &PMInfo) {
2264 if (llvm::Error Err =
2266 Error(std::move(Err));
2270 struct ModuleMacroRecord {
2283 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2285 Error(MaybeEntry.takeError());
2288 llvm::BitstreamEntry Entry = MaybeEntry.get();
2290 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2291 Error(
"malformed block record in AST file");
2298 Error(MaybePP.takeError());
2306 ModuleMacros.push_back(ModuleMacroRecord());
2307 auto &Info = ModuleMacros.back();
2308 Info.SubModID = getGlobalSubmoduleID(M,
Record[0]);
2309 Info.MI = getMacro(getGlobalMacroID(M,
Record[1]));
2310 for (
int I = 2, N =
Record.size(); I != N; ++I)
2311 Info.Overrides.push_back(getGlobalSubmoduleID(M,
Record[I]));
2316 Error(
"malformed block record in AST file");
2327 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2329 for (
auto &MMR : ModuleMacros) {
2331 for (
unsigned ModID : MMR.Overrides) {
2332 Module *Mod = getSubmodule(ModID);
2333 auto *Macro = PP.getModuleMacro(Mod, II);
2334 assert(Macro &&
"missing definition for overridden macro");
2335 Overrides.push_back(Macro);
2338 bool Inserted =
false;
2339 Module *Owner = getSubmodule(MMR.SubModID);
2340 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2351 unsigned Idx = 0, N =
Record.size();
2359 MD = PP.AllocateDefMacroDirective(MI, Loc);
2363 MD = PP.AllocateUndefMacroDirective(Loc);
2366 bool isPublic =
Record[Idx++];
2367 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2379 PP.setLoadedMacroDirective(II, Earliest, Latest);
2382bool ASTReader::shouldDisableValidationForFile(
2420 consumeError(std::move(Err));
2426 consumeError(MaybeCode.takeError());
2428 unsigned Code = MaybeCode.get();
2434 "invalid record type for input file");
2437 consumeError(Maybe.takeError());
2440 assert(
Record[0] == ID &&
"Bogus stored ID or offset");
2449 uint16_t AsRequestedLength =
Record[7];
2451 std::string NameAsRequested = Blob.substr(0, AsRequestedLength).str();
2452 std::string Name = Blob.substr(AsRequestedLength).str();
2454 ResolveImportedPath(F, NameAsRequested);
2455 ResolveImportedPath(F, Name);
2458 Name = NameAsRequested;
2460 return std::make_pair(std::move(NameAsRequested), std::move(Name));
2465 consumeError(MaybeEntry.takeError());
2466 llvm::BitstreamEntry Entry = MaybeEntry.get();
2467 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2468 "expected record type for input file hash");
2473 "invalid record type for input file hash");
2476 consumeError(Maybe.takeError());
2505 consumeError(std::move(Err));
2520 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2533 if ((Overridden || Transient || SkipChecks) && !
File)
2538 std::string ErrorStr =
"could not find file '";
2540 ErrorStr +=
"' referenced by AST file '";
2556 if ((!Overridden && !Transient) && !SkipChecks &&
2557 SM.isFileOverridden(*
File)) {
2571 enum ModificationKind {
2577 std::optional<int64_t> Old = std::nullopt;
2578 std::optional<int64_t> New = std::nullopt;
2580 auto HasInputContentChanged = [&](Change OriginalChange) {
2581 assert(ValidateASTInputFilesContent &&
2582 "We should only check the content of the inputs with "
2583 "ValidateASTInputFilesContent enabled.");
2585 if (StoredContentHash ==
static_cast<uint64_t>(llvm::hash_code(-1)))
2586 return OriginalChange;
2589 if (!MemBuffOrError) {
2591 return OriginalChange;
2592 std::string ErrorStr =
"could not get buffer for file '";
2593 ErrorStr +=
File->getName();
2596 return OriginalChange;
2600 auto ContentHash =
hash_value(MemBuffOrError.get()->getBuffer());
2601 if (StoredContentHash ==
static_cast<uint64_t>(ContentHash))
2602 return Change{Change::None};
2604 return Change{Change::Content};
2606 auto HasInputFileChanged = [&]() {
2607 if (StoredSize !=
File->getSize())
2608 return Change{Change::Size, StoredSize,
File->getSize()};
2609 if (!shouldDisableValidationForFile(F) && StoredTime &&
2610 StoredTime !=
File->getModificationTime()) {
2611 Change MTimeChange = {Change::ModTime, StoredTime,
2612 File->getModificationTime()};
2616 if (ValidateASTInputFilesContent)
2617 return HasInputContentChanged(MTimeChange);
2621 return Change{Change::None};
2624 bool IsOutOfDate =
false;
2625 auto FileChange = SkipChecks ? Change{Change::None} : HasInputFileChanged();
2631 FileChange = HasInputContentChanged(FileChange);
2634 if (!Overridden && FileChange.Kind != Change::None) {
2635 if (Complain && !Diags.isDiagnosticInFlight()) {
2638 while (!ImportStack.back()->ImportedBy.empty())
2639 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2642 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2643 Diag(diag::err_fe_ast_file_modified)
2645 << TopLevelPCHName << FileChange.Kind
2646 << (FileChange.Old && FileChange.New)
2647 << llvm::itostr(FileChange.Old.value_or(0))
2648 << llvm::itostr(FileChange.New.value_or(0));
2651 if (ImportStack.size() > 1) {
2652 Diag(diag::note_pch_required_by)
2653 <<
Filename << ImportStack[0]->FileName;
2654 for (
unsigned I = 1; I < ImportStack.size(); ++I)
2655 Diag(diag::note_pch_required_by)
2656 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2659 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2689 llvm::sys::path::append(Buffer, Prefix,
Filename);
2690 Filename.assign(Buffer.begin(), Buffer.end());
2705 llvm_unreachable(
"unknown ASTReadResult");
2709 BitstreamCursor &Stream,
unsigned ClientLoadCapabilities,
2711 std::string &SuggestedPredefines) {
2714 consumeError(std::move(Err));
2725 consumeError(MaybeEntry.takeError());
2728 llvm::BitstreamEntry Entry = MaybeEntry.get();
2730 switch (Entry.Kind) {
2731 case llvm::BitstreamEntry::Error:
2732 case llvm::BitstreamEntry::SubBlock:
2735 case llvm::BitstreamEntry::EndBlock:
2738 case llvm::BitstreamEntry::Record:
2746 if (!MaybeRecordType) {
2748 consumeError(MaybeRecordType.takeError());
2753 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2754 if (ParseLanguageOptions(
Record, Complain, Listener,
2755 AllowCompatibleConfigurationMismatch))
2756 Result = ConfigurationMismatch;
2761 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2762 if (ParseTargetOptions(
Record, Complain, Listener,
2763 AllowCompatibleConfigurationMismatch))
2764 Result = ConfigurationMismatch;
2769 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2770 if (!AllowCompatibleConfigurationMismatch &&
2771 ParseFileSystemOptions(
Record, Complain, Listener))
2772 Result = ConfigurationMismatch;
2777 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2778 if (!AllowCompatibleConfigurationMismatch &&
2779 ParseHeaderSearchOptions(
Record, Complain, Listener))
2780 Result = ConfigurationMismatch;
2785 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2786 if (!AllowCompatibleConfigurationMismatch &&
2787 ParsePreprocessorOptions(
Record, Complain, Listener,
2788 SuggestedPredefines))
2789 Result = ConfigurationMismatch;
2799 unsigned ClientLoadCapabilities) {
2800 BitstreamCursor &Stream = F.
Stream;
2803 Error(std::move(Err));
2813 bool HasReadUnhashedControlBlock =
false;
2814 auto readUnhashedControlBlockOnce = [&]() {
2815 if (!HasReadUnhashedControlBlock) {
2816 HasReadUnhashedControlBlock =
true;
2817 if (ASTReadResult
Result =
2818 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2824 bool DisableValidation = shouldDisableValidationForFile(F);
2828 unsigned NumInputs = 0;
2829 unsigned NumUserInputs = 0;
2830 StringRef BaseDirectoryAsWritten;
2834 Error(MaybeEntry.takeError());
2837 llvm::BitstreamEntry Entry = MaybeEntry.get();
2839 switch (Entry.Kind) {
2840 case llvm::BitstreamEntry::Error:
2841 Error(
"malformed block record in AST file");
2843 case llvm::BitstreamEntry::EndBlock: {
2846 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2851 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2858 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2864 unsigned N = ValidateSystemInputs ? NumInputs : NumUserInputs;
2870 for (
unsigned I = 0; I < N; ++I) {
2871 InputFile IF = getInputFile(F, I+1, Complain);
2883 for (
unsigned I = 0; I < N; ++I) {
2884 bool IsSystem = I >= NumUserInputs;
2895 case llvm::BitstreamEntry::SubBlock:
2899 if (llvm::Error Err = Stream.SkipBlock()) {
2900 Error(std::move(Err));
2904 Error(
"malformed block record in AST file");
2914 if (Listener && !ImportedBy) {
2920 bool AllowCompatibleConfigurationMismatch =
2924 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2925 AllowCompatibleConfigurationMismatch, *Listener,
2926 SuggestedPredefines);
2928 Error(
"malformed block record in AST file");
2932 if (DisableValidation ||
2933 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
2941 }
else if (llvm::Error Err = Stream.SkipBlock()) {
2942 Error(std::move(Err));
2948 if (llvm::Error Err = Stream.SkipBlock()) {
2949 Error(std::move(Err));
2955 case llvm::BitstreamEntry::Record:
2964 Stream.readRecord(Entry.ID,
Record, &Blob);
2965 if (!MaybeRecordType) {
2966 Error(MaybeRecordType.takeError());
2972 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2974 : diag::err_pch_version_too_new);
2978 bool hasErrors =
Record[7];
2979 if (hasErrors && !DisableValidation) {
2982 if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
2983 canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
2986 if (!AllowASTWithCompilerErrors) {
2987 Diag(diag::err_pch_with_compiler_errors);
2992 Diags.ErrorOccurred =
true;
2993 Diags.UncompilableErrorOccurred =
true;
2994 Diags.UnrecoverableErrorOccurred =
true;
3007 StringRef ASTBranch = Blob;
3008 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
3009 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3010 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
3020 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3024 unsigned Idx = 0, N =
Record.size();
3029 bool IsImportingStdCXXModule =
Record[Idx++];
3034 ReadUntranslatedSourceLocation(
Record[Idx++]);
3035 off_t StoredSize = !IsImportingStdCXXModule ? (off_t)
Record[Idx++] : 0;
3036 time_t StoredModTime =
3037 !IsImportingStdCXXModule ? (time_t)
Record[Idx++] : 0;
3040 if (!IsImportingStdCXXModule) {
3041 auto FirstSignatureByte =
Record.begin() + Idx;
3047 std::string ImportedName = ReadString(
Record, Idx);
3048 std::string ImportedFile;
3057 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
3058 ImportedName, !IsImportingStdCXXModule);
3062 if (!IsImportingStdCXXModule) {
3063 if (ImportedFile.empty()) {
3066 ImportedFile = ReadPath(BaseDirectoryAsWritten,
Record, Idx);
3069 }
else if (ImportedFile.empty()) {
3070 Diag(clang::diag::err_failed_to_find_module_file) << ImportedName;
3076 unsigned Capabilities = ClientLoadCapabilities;
3077 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3078 Capabilities &= ~ARR_Missing;
3081 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
3082 Loaded, StoredSize, StoredModTime,
3083 StoredSignature, Capabilities);
3086 bool recompilingFinalized =
3087 Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
3088 getModuleManager().getModuleCache().isPCMFinal(F.
FileName);
3090 Diag(diag::note_module_file_imported_by)
3092 if (recompilingFinalized)
3093 Diag(diag::note_module_file_conflict);
3096 case Failure:
return Failure;
3099 case OutOfDate:
return OutOfDate;
3101 case ConfigurationMismatch:
return ConfigurationMismatch;
3102 case HadErrors:
return HadErrors;
3122 Diag(diag::remark_module_import)
3124 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
3130 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3138 BaseDirectoryAsWritten = Blob;
3140 "MODULE_DIRECTORY found before MODULE_NAME");
3142 if (!PP.getPreprocessorOpts().ModulesCheckRelocated)
3146 Module *M = PP.getHeaderSearchInfo().lookupModule(
3153 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
3156 auto BuildDir = PP.getFileManager().getOptionalDirectoryRef(Blob);
3157 if (!BuildDir || *BuildDir != M->
Directory) {
3158 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
3159 Diag(diag::err_imported_module_relocated)
3170 if (ASTReadResult
Result =
3171 ReadModuleMapFileBlock(
Record, F, ImportedBy, ClientLoadCapabilities))
3177 NumUserInputs =
Record[1];
3179 (
const llvm::support::unaligned_uint64_t *)Blob.data();
3188llvm::Error ASTReader::ReadASTBlock(
ModuleFile &F,
3189 unsigned ClientLoadCapabilities) {
3190 BitstreamCursor &Stream = F.
Stream;
3192 if (llvm::Error Err = Stream.EnterSubBlock(
AST_BLOCK_ID))
3201 return MaybeEntry.takeError();
3202 llvm::BitstreamEntry Entry = MaybeEntry.get();
3204 switch (Entry.Kind) {
3205 case llvm::BitstreamEntry::Error:
3206 return llvm::createStringError(
3207 std::errc::illegal_byte_sequence,
3208 "error at end of module block in AST file");
3209 case llvm::BitstreamEntry::EndBlock:
3221 return llvm::Error::success();
3222 case llvm::BitstreamEntry::SubBlock:
3230 if (llvm::Error Err = Stream.SkipBlock())
3232 if (llvm::Error Err = ReadBlockAbbrevs(
3239 if (!PP.getExternalSource())
3240 PP.setExternalSource(
this);
3242 if (llvm::Error Err = Stream.SkipBlock())
3244 if (llvm::Error Err =
3253 if (llvm::Error Err = Stream.SkipBlock()) {
3262 if (!PP.getPreprocessingRecord())
3263 PP.createPreprocessingRecord();
3264 if (!PP.getPreprocessingRecord()->getExternalSource())
3265 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3269 if (llvm::Error Err = ReadSourceManagerBlock(F))
3274 if (llvm::Error Err = ReadSubmoduleBlock(F, ClientLoadCapabilities))
3279 BitstreamCursor
C = Stream;
3281 if (llvm::Error Err = Stream.SkipBlock())
3285 CommentsCursors.push_back(std::make_pair(
C, &F));
3290 if (llvm::Error Err = Stream.SkipBlock())
3296 case llvm::BitstreamEntry::Record:
3305 Stream.readRecord(Entry.ID,
Record, &Blob);
3306 if (!MaybeRecordType)
3307 return MaybeRecordType.takeError();
3339 return llvm::createStringError(
3340 std::errc::illegal_byte_sequence,
3341 "duplicate TYPE_OFFSET record in AST file");
3344 unsigned LocalBaseTypeIndex =
Record[1];
3349 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3353 std::make_pair(LocalBaseTypeIndex,
3363 return llvm::createStringError(
3364 std::errc::illegal_byte_sequence,
3365 "duplicate DECL_OFFSET record in AST file");
3368 unsigned LocalBaseDeclID =
Record[1];
3374 GlobalDeclMap.insert(std::make_pair(
3380 std::make_pair(LocalBaseDeclID, F.
BaseDeclID - LocalBaseDeclID));
3392 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3393 LexicalContents Contents(
3394 reinterpret_cast<const unalighed_decl_id_t *
>(Blob.data()),
3395 static_cast<unsigned int>(Blob.size() /
sizeof(
DeclID)));
3396 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3404 auto *
Data = (
const unsigned char*)Blob.data();
3405 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&F,
Data});
3408 if (
Decl *D = GetExistingDecl(ID))
3409 PendingUpdateRecords.push_back(
3410 PendingUpdateRecord(ID, D,
false));
3416 reinterpret_cast<const unsigned char *
>(Blob.data());
3424 PP.getIdentifierTable().setExternalIdentifierLookup(
this);
3430 return llvm::createStringError(
3431 std::errc::illegal_byte_sequence,
3432 "duplicate IDENTIFIER_OFFSET record in AST file");
3435 unsigned LocalBaseIdentifierID =
Record[1];
3441 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3447 std::make_pair(LocalBaseIdentifierID,
3450 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3463 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3464 EagerlyDeserializedDecls.push_back(
3472 getContext().getLangOpts().BuildingPCHWithObjectFile)
3473 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3474 EagerlyDeserializedDecls.push_back(
3479 if (SpecialTypes.empty()) {
3480 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3481 SpecialTypes.push_back(getGlobalTypeID(F,
Record[I]));
3485 if (SpecialTypes.size() !=
Record.size())
3486 return llvm::createStringError(std::errc::illegal_byte_sequence,
3487 "invalid special-types record");
3489 for (
unsigned I = 0, N =
Record.size(); I != N; ++I) {
3491 if (!SpecialTypes[I])
3492 SpecialTypes[I] =
ID;
3499 TotalNumStatements +=
Record[0];
3500 TotalNumMacros +=
Record[1];
3501 TotalLexicalDeclContexts +=
Record[2];
3502 TotalVisibleDeclContexts +=
Record[3];
3506 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3507 UnusedFileScopedDecls.push_back(
3512 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3513 DelegatingCtorDecls.push_back(
3518 if (
Record.size() % 3 != 0)
3519 return llvm::createStringError(std::errc::illegal_byte_sequence,
3520 "invalid weak identifiers record");
3524 WeakUndeclaredIdentifiers.clear();
3527 for (
unsigned I = 0, N =
Record.size(); I < N; ) {
3528 WeakUndeclaredIdentifiers.push_back(
3529 getGlobalIdentifierID(F,
Record[I++]));
3530 WeakUndeclaredIdentifiers.push_back(
3531 getGlobalIdentifierID(F,
Record[I++]));
3532 WeakUndeclaredIdentifiers.push_back(
3533 ReadSourceLocation(F,
Record, I).getRawEncoding());
3540 unsigned LocalBaseSelectorID =
Record[1];
3546 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3551 std::make_pair(LocalBaseSelectorID,
3563 = ASTSelectorLookupTable::Create(
3567 TotalNumMethodPoolEntries +=
Record[1];
3572 for (
unsigned Idx = 0, N =
Record.size() - 1; Idx < N; ) {
3573 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3575 ReferencedSelectorsData.push_back(ReadSourceLocation(F,
Record, Idx).
3584 PP.setPreambleRecordedPragmaAssumeNonNullLoc(
3585 ReadSourceLocation(F,
Record, Idx));
3591 unsigned Idx = 0, End =
Record.size() - 1;
3592 bool ReachedEOFWhileSkipping =
Record[Idx++];
3593 std::optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3594 if (ReachedEOFWhileSkipping) {
3597 bool FoundNonSkipPortion =
Record[Idx++];
3598 bool FoundElse =
Record[Idx++];
3600 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3601 FoundElse, ElseLoc);
3605 auto Loc = ReadSourceLocation(F,
Record, Idx);
3606 bool WasSkipping =
Record[Idx++];
3607 bool FoundNonSkip =
Record[Idx++];
3608 bool FoundElse =
Record[Idx++];
3609 ConditionalStack.push_back(
3610 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3612 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3617 if (!
Record.empty() && Listener)
3635 if (!Diags.isDiagnosticInFlight()) {
3637 SourceMgr.noteSLocAddressSpaceUsage(Diags);
3639 return llvm::createStringError(std::errc::invalid_argument,
3640 "ran out of source locations");
3645 unsigned RangeStart =
3647 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3652 GlobalSLocOffsetMap.insert(
3654 - SLocSpaceSize,&F));
3672 ParseLineTable(F,
Record);
3676 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3681 if (
Record.size() % 3 != 0)
3682 return llvm::createStringError(std::errc::illegal_byte_sequence,
3683 "Invalid VTABLE_USES record");
3690 for (
unsigned Idx = 0, N =
Record.size(); Idx != N; ) {
3691 VTableUses.push_back(
3693 ReadSourceLocation(F,
Record, Idx).getRawEncoding(),
3700 if (
Record.size() % 2 != 0)
3701 return llvm::createStringError(
3702 std::errc::illegal_byte_sequence,
3703 "Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3705 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3706 PendingInstantiations.push_back(
3708 ReadSourceLocation(F,
Record, I).getRawEncoding()});
3714 return llvm::createStringError(std::errc::illegal_byte_sequence,
3715 "Invalid SEMA_DECL_REFS block");
3716 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3725 unsigned LocalBasePreprocessedEntityID =
Record[0];
3727 unsigned StartingID;
3728 if (!PP.getPreprocessingRecord())
3729 PP.createPreprocessingRecord();
3730 if (!PP.getPreprocessingRecord()->getExternalSource())
3731 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3733 = PP.getPreprocessingRecord()
3740 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3745 std::make_pair(LocalBasePreprocessedEntityID,
3757 if (!PP.getPreprocessingRecord())
3758 PP.createPreprocessingRecord();
3759 if (!PP.getPreprocessingRecord()->getExternalSource())
3760 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3765 GlobalSkippedRangeMap.insert(
3771 if (
Record.size() % 2 != 0)
3772 return llvm::createStringError(
3773 std::errc::illegal_byte_sequence,
3774 "invalid DECL_UPDATE_OFFSETS block in AST file");
3775 for (
unsigned I = 0, N =
Record.size(); I != N; I += 2) {
3777 DeclUpdateOffsets[
ID].push_back(std::make_pair(&F,
Record[I + 1]));
3781 if (
Decl *D = GetExistingDecl(ID))
3782 PendingUpdateRecords.push_back(
3783 PendingUpdateRecord(ID, D,
false));
3788 if (
Record.size() % 3 != 0)
3789 return llvm::createStringError(
3790 std::errc::illegal_byte_sequence,
3791 "invalid DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD block in AST "
3793 for (
unsigned I = 0, N =
Record.size(); I != N; I += 3) {
3797 assert(BaseOffset &&
"Invalid DeclsBlockStartOffset for module file!");
3801 DelayedNamespaceOffsetMap[
ID] = {LexicalOffset, VisibleOffset};
3803 assert(!GetExistingDecl(ID) &&
3804 "We shouldn't load the namespace in the front of delayed "
3805 "namespace lexical and visible block");
3812 return llvm::createStringError(
3813 std::errc::illegal_byte_sequence,
3814 "duplicate OBJC_CATEGORIES_MAP record in AST file");
3827 CUDASpecialDeclRefs.clear();
3828 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3829 CUDASpecialDeclRefs.push_back(
3838 = HeaderFileInfoLookupTable::Create(
3842 &PP.getHeaderSearchInfo(),
3843 Blob.data() +
Record[2]));
3845 PP.getHeaderSearchInfo().SetExternalSource(
this);
3846 if (!PP.getHeaderSearchInfo().getExternalLookup())
3847 PP.getHeaderSearchInfo().SetExternalLookup(
this);
3853 FPPragmaOptions.swap(
Record);
3857 for (
unsigned I = 0, E =
Record.size(); I != E; ) {
3858 auto Name = ReadString(
Record, I);
3859 auto &OptInfo = OpenCLExtensions.OptMap[Name];
3860 OptInfo.Supported =
Record[I++] != 0;
3861 OptInfo.Enabled =
Record[I++] != 0;
3862 OptInfo.WithPragma =
Record[I++] != 0;
3863 OptInfo.Avail =
Record[I++];
3864 OptInfo.Core =
Record[I++];
3865 OptInfo.Opt =
Record[I++];
3870 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3871 TentativeDefinitions.push_back(
3876 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3881 if (
Record.size() % 2 != 0)
3882 return llvm::createStringError(std::errc::illegal_byte_sequence,
3883 "invalid undefined-but-used record");
3884 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3885 UndefinedButUsed.push_back(
3887 ReadSourceLocation(F,
Record, I).getRawEncoding()});
3892 for (
unsigned I = 0, N =
Record.size(); I != N;) {
3893 DelayedDeleteExprs.push_back(
3896 DelayedDeleteExprs.push_back(Count);
3897 for (uint64_t
C = 0;
C < Count; ++
C) {
3898 DelayedDeleteExprs.push_back(ReadSourceLocation(F,
Record, I).getRawEncoding());
3899 bool IsArrayForm =
Record[I++] == 1;
3900 DelayedDeleteExprs.push_back(IsArrayForm);
3910 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3911 unsigned GlobalID = getGlobalSubmoduleID(F,
Record[I++]);
3914 PendingImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3915 if (DeserializationListener)
3916 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3924 return llvm::createStringError(
3925 std::errc::illegal_byte_sequence,
3926 "duplicate MACRO_OFFSET record in AST file");
3929 unsigned LocalBaseMacroID =
Record[1];
3935 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3939 std::make_pair(LocalBaseMacroID,
3948 LateParsedTemplates.emplace_back(
3949 std::piecewise_construct, std::forward_as_tuple(&F),
3955 return llvm::createStringError(std::errc::illegal_byte_sequence,
3956 "invalid pragma optimize record");
3957 OptimizeOffPragmaLocation = ReadSourceLocation(F,
Record[0]);
3962 return llvm::createStringError(std::errc::illegal_byte_sequence,
3963 "invalid pragma ms_struct record");
3964 PragmaMSStructState =
Record[0];
3969 return llvm::createStringError(
3970 std::errc::illegal_byte_sequence,
3971 "invalid pragma pointers to members record");
3972 PragmaMSPointersToMembersState =
Record[0];
3973 PointersToMembersPragmaLocation = ReadSourceLocation(F,
Record[1]);
3977 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3978 UnusedLocalTypedefNameCandidates.push_back(
3984 return llvm::createStringError(std::errc::illegal_byte_sequence,
3985 "invalid cuda pragma options record");
3986 ForceHostDeviceDepth =
Record[0];
3991 return llvm::createStringError(std::errc::illegal_byte_sequence,
3992 "invalid pragma pack record");
3993 PragmaAlignPackCurrentValue = ReadAlignPackInfo(
Record[0]);
3994 PragmaAlignPackCurrentLocation = ReadSourceLocation(F,
Record[1]);
3995 unsigned NumStackEntries =
Record[2];
3998 PragmaAlignPackStack.clear();
3999 for (
unsigned I = 0; I < NumStackEntries; ++I) {
4000 PragmaAlignPackStackEntry Entry;
4001 Entry.Value = ReadAlignPackInfo(
Record[Idx++]);
4002 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
4003 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
4004 PragmaAlignPackStrings.push_back(ReadString(
Record, Idx));
4005 Entry.SlotLabel = PragmaAlignPackStrings.back();
4006 PragmaAlignPackStack.push_back(Entry);
4013 return llvm::createStringError(std::errc::illegal_byte_sequence,
4014 "invalid pragma float control record");
4016 FpPragmaCurrentLocation = ReadSourceLocation(F,
Record[1]);
4017 unsigned NumStackEntries =
Record[2];
4020 FpPragmaStack.clear();
4021 for (
unsigned I = 0; I < NumStackEntries; ++I) {
4022 FpPragmaStackEntry Entry;
4024 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
4025 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
4026 FpPragmaStrings.push_back(ReadString(
Record, Idx));
4027 Entry.SlotLabel = FpPragmaStrings.back();
4028 FpPragmaStack.push_back(Entry);
4034 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
4035 DeclsToCheckForDeferredDiags.insert(
4042void ASTReader::ReadModuleOffsetMap(
ModuleFile &F)
const {
4057 using SLocRemapBuilder =
4070 while (
Data < DataEnd) {
4074 using namespace llvm::support;
4076 endian::readNext<uint8_t, llvm::endianness::little>(
Data));
4077 uint16_t Len = endian::readNext<uint16_t, llvm::endianness::little>(
Data);
4078 StringRef Name = StringRef((
const char*)
Data, Len);
4082 ? ModuleMgr.lookupByModuleName(Name)
4083 : ModuleMgr.lookupByFileName(Name));
4086 "SourceLocation remap refers to unknown module, cannot find ";
4087 Msg.append(std::string(Name));
4093 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4094 uint32_t IdentifierIDOffset =
4095 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4096 uint32_t MacroIDOffset =
4097 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4098 uint32_t PreprocessedEntityIDOffset =
4099 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4100 uint32_t SubmoduleIDOffset =
4101 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4102 uint32_t SelectorIDOffset =
4103 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4104 uint32_t DeclIDOffset =
4105 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4106 uint32_t TypeIndexOffset =
4107 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
4109 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
4110 RemapBuilder &Remap) {
4111 constexpr uint32_t
None = std::numeric_limits<uint32_t>::max();
4113 Remap.insert(std::make_pair(Offset,
4114 static_cast<int>(BaseOffset - Offset)));
4118 std::numeric_limits<SourceLocation::UIntTy>::max();
4119 if (SLocOffset != SLocNone)
4125 mapOffset(MacroIDOffset, OM->
BaseMacroID, MacroRemap);
4127 PreprocessedEntityRemap);
4130 mapOffset(DeclIDOffset, OM->
BaseDeclID, DeclRemap);
4141 unsigned ClientLoadCapabilities) {
4150 "MODULE_NAME should come before MODULE_MAP_FILE");
4151 if (PP.getPreprocessorOpts().ModulesCheckRelocated &&
4157 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
4159 M ? Map.getModuleMapFileForUniquing(M) : std::nullopt;
4161 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
4164 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities)) {
4165 if (
auto ASTFE = M ? M->
getASTFile() : std::nullopt) {
4168 << ASTFE->getName();
4171 Diag(diag::err_imported_module_not_found)
4179 Diag(diag::note_imported_by_pch_module_not_found)
4186 assert(M && M->
Name == F.
ModuleName &&
"found module with different name");
4190 if (!StoredModMap || *StoredModMap != ModMap) {
4191 assert(ModMap &&
"found module is missing module map file");
4193 "top-level import should be verified");
4195 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4196 Diag(diag::err_imported_module_modmap_changed)
4203 for (
unsigned I = 0, N =
Record[Idx++]; I < N; ++I) {
4208 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4209 Error(
"could not find file '" +
Filename +
"' referenced by AST file");
4212 AdditionalStoredMaps.insert(*SF);
4217 if (
auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
4221 if (!AdditionalStoredMaps.erase(ModMap)) {
4222 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4223 Diag(diag::err_module_different_modmap)
4233 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4234 Diag(diag::err_module_different_modmap)
4255 : Known->second.second;
4257 for (
ObjCMethodList *List = &Start; List; List = List->getNext()) {
4259 if (List->getMethod() == Method) {
4267 if (List->getNext())
4268 List->setMethod(List->getNext()->getMethod());
4270 List->setMethod(Method);
4276 for (
Decl *D : Names) {
4277 bool wasHidden = !D->isUnconditionallyVisible();
4278 D->setVisibleDespiteOwningModule();
4280 if (wasHidden && SemaObj) {
4293 Stack.push_back(Mod);
4294 while (!Stack.empty()) {
4295 Mod = Stack.pop_back_val();
4297 if (NameVisibility <= Mod->NameVisibility) {
4313 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4314 if (Hidden != HiddenNamesMap.end()) {
4316 HiddenNamesMap.erase(Hidden);
4318 assert(!HiddenNamesMap.contains(Mod) &&
4319 "making names visible added hidden names");
4326 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4328 if (
Visited.insert(Exported).second)
4329 Stack.push_back(Exported);
4344 getContext().mergeDefinitionIntoModule(
4347 PendingMergedDefinitionsToDeduplicate.insert(Def);
4356 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4357 !PP.getLangOpts().Modules)
4361 TriedLoadingGlobalIndex =
true;
4362 StringRef ModuleCachePath
4363 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4364 std::pair<GlobalModuleIndex *, llvm::Error>
Result =
4366 if (llvm::Error Err = std::move(
Result.second)) {
4368 consumeError(std::move(Err));
4372 GlobalIndex.reset(
Result.first);
4373 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4378 return PP.getLangOpts().Modules && UseGlobalIndex &&
4379 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4386 llvm::raw_fd_ostream OS(TimestampFilename, EC,
4387 llvm::sys::fs::OF_TextWithCRLF);
4390 OS <<
"Timestamp file\n";
4403 consumeError(MaybeEntry.takeError());
4406 llvm::BitstreamEntry Entry = MaybeEntry.get();
4408 switch (Entry.Kind) {
4409 case llvm::BitstreamEntry::Error:
4410 case llvm::BitstreamEntry::EndBlock:
4413 case llvm::BitstreamEntry::Record:
4419 consumeError(Skipped.takeError());
4423 case llvm::BitstreamEntry::SubBlock:
4424 if (Entry.ID == BlockID) {
4425 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4427 consumeError(std::move(Err));
4434 if (llvm::Error Err = Cursor.SkipBlock()) {
4436 consumeError(std::move(Err));
4445 unsigned ClientLoadCapabilities,
4447 llvm::TimeTraceScope scope(
"ReadAST",
FileName);
4451 CurrentDeserializingModuleKind,
Type);
4457 unsigned PreviousGeneration = 0;
4459 PreviousGeneration = incrementGeneration(*ContextObj);
4461 unsigned NumModules = ModuleMgr.size();
4466 ClientLoadCapabilities)) {
4467 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules);
4471 GlobalIndex.reset();
4472 ModuleMgr.setGlobalIndex(
nullptr);
4476 if (NewLoadedModuleFile && !Loaded.empty())
4477 *NewLoadedModuleFile = Loaded.back().Mod;
4488 for (ImportedModule &M : Loaded) {
4490 llvm::TimeTraceScope Scope2(
"Read Loaded AST", F.
ModuleName);
4493 if (llvm::Error Err = ReadASTBlock(F, ClientLoadCapabilities)) {
4494 Error(std::move(Err));
4500 Error(diag::err_module_file_missing_top_level_submodule, F.
FileName);
4506 if (llvm::Error Err = ReadExtensionBlock(F)) {
4507 Error(std::move(Err));
4520 for (ImportedModule &M : Loaded) {
4536 if (!PP.getLangOpts().CPlusPlus) {
4543 auto It = PP.getIdentifierTable().find(Key);
4544 if (It == PP.getIdentifierTable().end())
4553 II = &PP.getIdentifierTable().getOwn(Key);
4564 SetIdentifierInfo(ID, II);
4571 for (
auto &
Id : PP.getIdentifierTable())
4572 Id.second->setOutOfDate(
true);
4575 for (
const auto &Sel : SelectorGeneration)
4576 SelectorOutOfDate[Sel.first] =
true;
4580 for (ImportedModule &M : Loaded) {
4583 ModuleMgr.moduleFileAccepted(&F);
4592 F.
ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4596 for (
unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4597 UnresolvedModuleRef &
Unresolved = UnresolvedModuleRefs[I];
4599 Module *ResolvedMod = getSubmodule(GlobalID);
4602 case UnresolvedModuleRef::Conflict:
4605 Conflict.
Other = ResolvedMod;
4607 Unresolved.Mod->Conflicts.push_back(Conflict);
4611 case UnresolvedModuleRef::Import:
4616 case UnresolvedModuleRef::Affecting:
4618 Unresolved.Mod->AffectingClangModules.insert(ResolvedMod);
4621 case UnresolvedModuleRef::Export:
4628 UnresolvedModuleRefs.clear();
4635 InitializeContext();
4640 if (DeserializationListener)
4641 DeserializationListener->ReaderInitialized(
this);
4643 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4658 for (
unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4659 loadObjCCategories(
GlobalDeclID(ObjCClassesLoaded[I]->getGlobalID()),
4660 ObjCClassesLoaded[I], PreviousGeneration);
4669 for (
unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4670 ImportedModule &M = Loaded[I];
4687 if (!Stream.canSkipToPos(4))
4688 return llvm::createStringError(std::errc::illegal_byte_sequence,
4689 "file too small to contain AST file magic");
4690 for (
unsigned C : {
'C',
'P',
'C',
'H'})
4693 return llvm::createStringError(
4694 std::errc::illegal_byte_sequence,
4695 "file doesn't start with AST file magic");
4697 return Res.takeError();
4698 return llvm::Error::success();
4713 llvm_unreachable(
"unknown module kind");
4717ASTReader::ReadASTCore(StringRef
FileName,
4722 off_t ExpectedSize, time_t ExpectedModTime,
4724 unsigned ClientLoadCapabilities) {
4726 std::string ErrorStr;
4728 = ModuleMgr.addModule(
FileName,
Type, ImportLoc, ImportedBy,
4729 getGeneration(), ExpectedSize, ExpectedModTime,
4733 switch (AddResult) {
4735 Diag(diag::remark_module_import)
4737 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
4747 if (ClientLoadCapabilities & ARR_Missing)
4751 Diag(diag::err_ast_file_not_found)
4759 if (ClientLoadCapabilities & ARR_OutOfDate)
4763 Diag(diag::err_ast_file_out_of_date)
4769 assert(M &&
"Missing module file");
4771 bool ShouldFinalizePCM =
false;
4772 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4773 auto &MC = getModuleManager().getModuleCache();
4774 if (ShouldFinalizePCM)
4780 BitstreamCursor &Stream = F.
Stream;
4781 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4782 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4786 Diag(diag::err_ast_file_invalid)
4792 bool HaveReadControlBlock =
false;
4796 Error(MaybeEntry.takeError());
4799 llvm::BitstreamEntry Entry = MaybeEntry.get();
4801 switch (Entry.Kind) {
4802 case llvm::BitstreamEntry::Error:
4803 case llvm::BitstreamEntry::Record:
4804 case llvm::BitstreamEntry::EndBlock:
4805 Error(
"invalid record at top-level of AST file");
4808 case llvm::BitstreamEntry::SubBlock:
4814 HaveReadControlBlock =
true;
4815 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4823 F.ModuleName.empty()) {
4825 if (
Result != OutOfDate ||
4826 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4832 case Failure:
return Failure;
4833 case Missing:
return Missing;
4834 case OutOfDate:
return OutOfDate;
4836 case ConfigurationMismatch:
return ConfigurationMismatch;
4837 case HadErrors:
return HadErrors;
4842 if (!HaveReadControlBlock) {
4843 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4844 Diag(diag::err_pch_version_too_old);
4849 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4850 ShouldFinalizePCM =
true;
4854 if (llvm::Error Err = Stream.SkipBlock()) {
4855 Error(std::move(Err));
4862 llvm_unreachable(
"unexpected break; expected return");
4866ASTReader::readUnhashedControlBlock(
ModuleFile &F,
bool WasImportedBy,
4867 unsigned ClientLoadCapabilities) {
4869 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4870 bool AllowCompatibleConfigurationMismatch =
4872 bool DisableValidation = shouldDisableValidationForFile(F);
4874 ASTReadResult
Result = readUnhashedControlBlockImpl(
4875 &F, F.
Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4881 if (DisableValidation || WasImportedBy ||
4882 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
4886 Error(
"malformed block record in AST file");
4909 if (getModuleManager().getModuleCache().isPCMFinal(F.
FileName)) {
4910 Diag(diag::warn_module_system_bit_conflict) << F.
FileName;
4919 ModuleFile *F, llvm::StringRef StreamData,
unsigned ClientLoadCapabilities,
4921 bool ValidateDiagnosticOptions) {
4923 BitstreamCursor Stream(StreamData);
4928 consumeError(std::move(Err));
4943 consumeError(MaybeEntry.takeError());
4946 llvm::BitstreamEntry Entry = MaybeEntry.get();
4948 switch (Entry.Kind) {
4949 case llvm::BitstreamEntry::Error:
4950 case llvm::BitstreamEntry::SubBlock:
4953 case llvm::BitstreamEntry::EndBlock:
4956 case llvm::BitstreamEntry::Record:
4965 Stream.readRecord(Entry.ID,
Record, &Blob);
4966 if (!MaybeRecordType) {
4975 "Dummy AST file signature not backpatched in ASTWriter.");
4982 "Dummy AST block hash not backpatched in ASTWriter.");
4986 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4987 if (Listener && ValidateDiagnosticOptions &&
4988 !AllowCompatibleConfigurationMismatch &&
4989 ParseDiagnosticOptions(
Record, Complain, *Listener))
4994 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
4995 if (Listener && !AllowCompatibleConfigurationMismatch &&
4996 ParseHeaderSearchPaths(
Record, Complain, *Listener))
4997 Result = ConfigurationMismatch;
5026 if (
Record.size() < 4)
return true;
5031 unsigned BlockNameLen =
Record[2];
5032 unsigned UserInfoLen =
Record[3];
5034 if (BlockNameLen + UserInfoLen > Blob.size())
return true;
5036 Metadata.
BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
5037 Metadata.
UserInfo = std::string(Blob.data() + BlockNameLen,
5038 Blob.data() + BlockNameLen + UserInfoLen);
5042llvm::Error ASTReader::ReadExtensionBlock(
ModuleFile &F) {
5043 BitstreamCursor &Stream = F.
Stream;
5049 return MaybeEntry.takeError();
5050 llvm::BitstreamEntry Entry = MaybeEntry.get();
5052 switch (Entry.Kind) {
5053 case llvm::BitstreamEntry::SubBlock:
5054 if (llvm::Error Err = Stream.SkipBlock())
5057 case llvm::BitstreamEntry::EndBlock:
5058 return llvm::Error::success();
5059 case llvm::BitstreamEntry::Error:
5060 return llvm::createStringError(std::errc::illegal_byte_sequence,
5061 "malformed block record in AST file");
5062 case llvm::BitstreamEntry::Record:
5069 Stream.readRecord(Entry.ID,
Record, &Blob);
5071 return MaybeRecCode.takeError();
5072 switch (MaybeRecCode.get()) {
5076 return llvm::createStringError(
5077 std::errc::illegal_byte_sequence,
5078 "malformed EXTENSION_METADATA in AST file");
5081 auto Known = ModuleFileExtensions.find(Metadata.
BlockName);
5082 if (Known == ModuleFileExtensions.end())
break;
5085 if (
auto Reader = Known->second->createExtensionReader(Metadata, *
this,
5095 return llvm::Error::success();
5099 assert(ContextObj &&
"no context to initialize");
5103 if (DeserializationListener)
5113 if (!Context.CFConstantStringTypeDecl)
5120 Error(
"FILE type is NULL");
5124 if (!Context.FILEDecl) {
5130 Error(
"Invalid FILE type in AST file");
5139 QualType Jmp_bufType = GetType(Jmp_buf);
5140 if (Jmp_bufType.
isNull()) {
5141 Error(
"jmp_buf type is NULL");
5145 if (!Context.jmp_bufDecl) {
5151 Error(
"Invalid jmp_buf type in AST file");
5160 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
5161 if (Sigjmp_bufType.
isNull()) {
5162 Error(
"sigjmp_buf type is NULL");
5166 if (!Context.sigjmp_bufDecl) {
5171 assert(Tag &&
"Invalid sigjmp_buf type in AST file");
5177 if (
unsigned ObjCIdRedef
5179 if (Context.ObjCIdRedefinitionType.
isNull())
5180 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
5183 if (
unsigned ObjCClassRedef
5185 if (Context.ObjCClassRedefinitionType.
isNull())
5186 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
5189 if (
unsigned ObjCSelRedef
5191 if (Context.ObjCSelRedefinitionType.
isNull())
5192 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
5196 QualType Ucontext_tType = GetType(Ucontext_t);
5197 if (Ucontext_tType.
isNull()) {
5198 Error(
"ucontext_t type is NULL");
5202 if (!Context.ucontext_tDecl) {
5207 assert(Tag &&
"Invalid ucontext_t type in AST file");
5217 if (!CUDASpecialDeclRefs.empty()) {
5218 assert(CUDASpecialDeclRefs.size() == 1 &&
"More decl refs than expected!");
5220 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5225 for (
auto &Import : PendingImportedModules) {
5226 if (
Module *Imported = getSubmodule(Import.ID)) {
5229 if (Import.ImportLoc.isValid())
5230 PP.makeModuleVisible(Imported, Import.ImportLoc);
5237 PendingImportedModulesSema.append(PendingImportedModules);
5238 PendingImportedModules.clear();
5248 BitstreamCursor Stream(
PCH);
5251 consumeError(std::move(Err));
5263 Stream.advanceSkippingSubblocks();
5266 consumeError(MaybeEntry.takeError());
5269 llvm::BitstreamEntry Entry = MaybeEntry.get();
5271 if (Entry.Kind != llvm::BitstreamEntry::Record)
5279 consumeError(MaybeRecord.takeError());
5285 "Dummy AST file signature not backpatched in ASTWriter.");
5295 const std::string &ASTFileName,
FileManager &FileMgr,
5301 Diags.
Report(diag::err_fe_unable_to_read_pch_file)
5302 << ASTFileName << Buffer.getError().message();
5303 return std::string();
5307 BitstreamCursor Stream(PCHContainerRdr.
ExtractPCH(**Buffer));
5311 Diags.
Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5312 return std::string();
5317 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5318 return std::string();
5325 Stream.advanceSkippingSubblocks();
5328 consumeError(MaybeEntry.takeError());
5329 return std::string();
5331 llvm::BitstreamEntry Entry = MaybeEntry.get();
5333 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5334 return std::string();
5336 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5337 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5338 return std::string();
5346 consumeError(MaybeRecord.takeError());
5347 return std::string();
5360 std::string ExistingModuleCachePath;
5362 bool StrictOptionMatches;
5365 SimplePCHValidator(
const LangOptions &ExistingLangOpts,
5368 StringRef ExistingModuleCachePath,
FileManager &FileMgr,
5369 bool StrictOptionMatches)
5370 : ExistingLangOpts(ExistingLangOpts),
5371 ExistingTargetOpts(ExistingTargetOpts),
5372 ExistingPPOpts(ExistingPPOpts),
5373 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr),
5374 StrictOptionMatches(StrictOptionMatches) {}
5376 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
5377 bool AllowCompatibleDifferences)
override {
5379 AllowCompatibleDifferences);
5382 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
5383 bool AllowCompatibleDifferences)
override {
5385 AllowCompatibleDifferences);
5389 StringRef SpecificModuleCachePath,
5390 bool Complain)
override {
5392 ExistingModuleCachePath,
nullptr,
5393 ExistingLangOpts, ExistingPPOpts);
5397 bool ReadMacros,
bool Complain,
5398 std::string &SuggestedPredefines)
override {
5400 PPOpts, ExistingPPOpts, ReadMacros,
nullptr, FileMgr,
5401 SuggestedPredefines, ExistingLangOpts,
5414 unsigned ClientLoadCapabilities) {
5416 std::unique_ptr<llvm::MemoryBuffer> OwnedBuffer;
5428 OwnedBuffer = std::move(*BufferOrErr);
5429 Buffer = OwnedBuffer.get();
5433 StringRef Bytes = PCHContainerRdr.
ExtractPCH(*Buffer);
5434 BitstreamCursor Stream(Bytes);
5438 consumeError(std::move(Err));
5449 BitstreamCursor InputFilesCursor;
5450 uint64_t InputFilesOffsetBase = 0;
5453 std::string ModuleDir;
5454 bool DoneWithControlBlock =
false;
5455 while (!DoneWithControlBlock) {
5459 consumeError(MaybeEntry.takeError());
5462 llvm::BitstreamEntry Entry = MaybeEntry.get();
5464 switch (Entry.Kind) {
5465 case llvm::BitstreamEntry::SubBlock: {
5468 std::string IgnoredSuggestedPredefines;
5469 if (ReadOptionsBlock(Stream, ClientLoadCapabilities,
5471 Listener, IgnoredSuggestedPredefines) !=
Success)
5477 InputFilesCursor = Stream;
5478 if (llvm::Error Err = Stream.SkipBlock()) {
5480 consumeError(std::move(Err));
5483 if (NeedsInputFiles &&
5486 InputFilesOffsetBase = InputFilesCursor.GetCurrentBitNo();
5490 if (llvm::Error Err = Stream.SkipBlock()) {
5492 consumeError(std::move(Err));
5501 case llvm::BitstreamEntry::EndBlock:
5502 DoneWithControlBlock =
true;
5505 case llvm::BitstreamEntry::Error:
5508 case llvm::BitstreamEntry::Record:
5512 if (DoneWithControlBlock)
break;
5517 Stream.readRecord(Entry.ID,
Record, &Blob);
5518 if (!MaybeRecCode) {
5533 ModuleDir = std::string(Blob);
5537 auto Path = ReadString(
Record, Idx);
5538 ResolveImportedPath(Path, ModuleDir);
5543 if (!NeedsInputFiles)
5546 unsigned NumInputFiles =
Record[0];
5547 unsigned NumUserFiles =
Record[1];
5548 const llvm::support::unaligned_uint64_t *InputFileOffs =
5549 (
const llvm::support::unaligned_uint64_t *)Blob.data();
5550 for (
unsigned I = 0; I != NumInputFiles; ++I) {
5552 bool isSystemFile = I >= NumUserFiles;
5554 if (isSystemFile && !NeedsSystemInputFiles)
5557 BitstreamCursor &Cursor = InputFilesCursor;
5559 if (llvm::Error Err =
5560 Cursor.JumpToBit(InputFilesOffsetBase + InputFileOffs[I])) {
5562 consumeError(std::move(Err));
5568 consumeError(MaybeCode.takeError());
5570 unsigned Code = MaybeCode.get();
5574 bool shouldContinue =
false;
5576 Cursor.readRecord(Code,
Record, &Blob);
5577 if (!MaybeRecordType) {
5579 consumeError(MaybeRecordType.takeError());
5585 bool Overridden =
static_cast<bool>(
Record[3]);
5586 std::string
Filename = std::string(Blob);
5587 ResolveImportedPath(
Filename, ModuleDir);
5589 Filename, isSystemFile, Overridden,
false);
5592 if (!shouldContinue)
5602 unsigned Idx = 0, N =
Record.size();
5608 bool IsStandardCXXModule =
Record[Idx++];
5615 if (IsStandardCXXModule) {
5616 std::string ModuleName = ReadString(
Record, Idx);
5623 std::string ModuleName = ReadString(
Record, Idx);
5625 ResolveImportedPath(
Filename, ModuleDir);
5638 if (FindModuleFileExtensions) {
5639 BitstreamCursor SavedStream = Stream;
5641 bool DoneWithExtensionBlock =
false;
5642 while (!DoneWithExtensionBlock) {
5648 llvm::BitstreamEntry Entry = MaybeEntry.get();
5650 switch (Entry.Kind) {
5651 case llvm::BitstreamEntry::SubBlock:
5652 if (llvm::Error Err = Stream.SkipBlock()) {
5654 consumeError(std::move(Err));
5659 case llvm::BitstreamEntry::EndBlock:
5660 DoneWithExtensionBlock =
true;
5663 case llvm::BitstreamEntry::Error:
5666 case llvm::BitstreamEntry::Record:
5673 Stream.readRecord(Entry.ID,
Record, &Blob);
5674 if (!MaybeRecCode) {
5678 switch (MaybeRecCode.get()) {
5690 Stream = SavedStream;
5694 if (readUnhashedControlBlockImpl(
5695 nullptr, Bytes, ClientLoadCapabilities,
5697 ValidateDiagnosticOptions) !=
Success)
5709 StringRef ExistingModuleCachePath,
5710 bool RequireStrictOptionMatches) {
5711 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
5712 ExistingModuleCachePath, FileMgr,
5713 RequireStrictOptionMatches);
5714 return !readASTFileControlBlock(
Filename, FileMgr, ModuleCache,
5720llvm::Error ASTReader::ReadSubmoduleBlock(
ModuleFile &F,
5721 unsigned ClientLoadCapabilities) {
5726 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5728 Module *CurrentModule =
nullptr;
5732 F.
Stream.advanceSkippingSubblocks();
5734 return MaybeEntry.takeError();
5735 llvm::BitstreamEntry Entry = MaybeEntry.get();
5737 switch (Entry.Kind) {
5738 case llvm::BitstreamEntry::SubBlock:
5739 case llvm::BitstreamEntry::Error:
5740 return llvm::createStringError(std::errc::illegal_byte_sequence,
5741 "malformed block record in AST file");
5742 case llvm::BitstreamEntry::EndBlock:
5743 return llvm::Error::success();
5744 case llvm::BitstreamEntry::Record:
5754 return MaybeKind.takeError();
5755 unsigned Kind = MaybeKind.get();
5758 return llvm::createStringError(
5759 std::errc::illegal_byte_sequence,
5760 "submodule metadata record should be at beginning of block");
5775 return llvm::createStringError(std::errc::illegal_byte_sequence,
5776 "malformed module definition");
5778 StringRef Name = Blob;
5784 bool IsFramework =
Record[Idx++];
5785 bool IsExplicit =
Record[Idx++];
5786 bool IsSystem =
Record[Idx++];
5787 bool IsExternC =
Record[Idx++];
5788 bool InferSubmodules =
Record[Idx++];
5789 bool InferExplicitSubmodules =
Record[Idx++];
5790 bool InferExportWildcard =
Record[Idx++];
5791 bool ConfigMacrosExhaustive =
Record[Idx++];
5792 bool ModuleMapIsPrivate =
Record[Idx++];
5793 bool NamedModuleHasInit =
Record[Idx++];
5795 Module *ParentModule =
nullptr;
5797 ParentModule = getSubmodule(
Parent);
5808 if (GlobalIndex >= SubmodulesLoaded.size() ||
5809 SubmodulesLoaded[GlobalIndex])
5810 return llvm::createStringError(std::errc::invalid_argument,
5811 "too many submodules");
5813 if (!ParentModule) {
5816 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
5818 CurFile != F.
File) {
5819 auto ConflictError =
5821 ContextObj->DiagAllocator)
5845 if (DeserializationListener)
5846 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5848 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5873 std::string
Filename = std::string(Blob);
5875 if (
auto Umbrella = PP.getFileManager().getOptionalFileRef(
Filename)) {
5903 std::string HeaderName(Blob);
5904 ResolveImportedPath(F, HeaderName);
5911 std::string Dirname = std::string(Blob);
5912 ResolveImportedPath(F, Dirname);
5914 PP.getFileManager().getOptionalDirectoryRef(Dirname)) {
5926 unsigned LocalBaseSubmoduleID =
Record[1];
5930 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5935 std::make_pair(LocalBaseSubmoduleID,
5944 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5949 Unresolved.Kind = UnresolvedModuleRef::Import;
5956 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5961 Unresolved.Kind = UnresolvedModuleRef::Affecting;
5968 for (
unsigned Idx = 0; Idx + 1 <
Record.size(); Idx += 2) {
5973 Unresolved.Kind = UnresolvedModuleRef::Export;
5985 PP.getTargetInfo());
6003 Unresolved.Kind = UnresolvedModuleRef::Conflict;
6015 Inits.push_back(getGlobalDeclID(F,
LocalDeclID(ID)).get());
6016 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
6035bool ASTReader::ParseLanguageOptions(
const RecordData &
Record,
6038 bool AllowCompatibleDifferences) {
6041#define LANGOPT(Name, Bits, Default, Description) \
6042 LangOpts.Name = Record[Idx++];
6043#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
6044 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
6045#include "clang/Basic/LangOptions.def"
6046#define SANITIZER(NAME, ID) \
6047 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
6048#include "clang/Basic/Sanitizers.def"
6050 for (
unsigned N =
Record[Idx++]; N; --N)
6054 VersionTuple runtimeVersion = ReadVersionTuple(
Record, Idx);
6060 for (
unsigned N =
Record[Idx++]; N; --N) {
6062 ReadString(
Record, Idx));
6067 for (
unsigned N =
Record[Idx++]; N; --N) {
6074 AllowCompatibleDifferences);
6077bool ASTReader::ParseTargetOptions(
const RecordData &
Record,
bool Complain,
6079 bool AllowCompatibleDifferences) {
6083 TargetOpts.
CPU = ReadString(
Record, Idx);
6085 TargetOpts.
ABI = ReadString(
Record, Idx);
6086 for (
unsigned N =
Record[Idx++]; N; --N) {
6089 for (
unsigned N =
Record[Idx++]; N; --N) {
6094 AllowCompatibleDifferences);
6097bool ASTReader::ParseDiagnosticOptions(
const RecordData &
Record,
bool Complain,
6101#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
6102#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
6103 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
6104#include "clang/Basic/DiagnosticOptions.def"
6106 for (
unsigned N =
Record[Idx++]; N; --N)
6107 DiagOpts->Warnings.push_back(ReadString(
Record, Idx));
6108 for (
unsigned N =
Record[Idx++]; N; --N)
6109 DiagOpts->Remarks.push_back(ReadString(
Record, Idx));
6114bool ASTReader::ParseFileSystemOptions(
const RecordData &
Record,
bool Complain,
6122bool ASTReader::ParseHeaderSearchOptions(
const RecordData &
Record,
6140 std::string SpecificModuleCachePath = ReadString(
Record, Idx);
6146bool ASTReader::ParseHeaderSearchPaths(
const RecordData &
Record,
bool Complain,
6152 for (
unsigned N =
Record[Idx++]; N; --N) {
6153 std::string Path = ReadString(
Record, Idx);
6156 bool IsFramework =
Record[Idx++];
6157 bool IgnoreSysRoot =
Record[Idx++];
6163 for (
unsigned N =
Record[Idx++]; N; --N) {
6164 std::string Prefix = ReadString(
Record, Idx);
6165 bool IsSystemHeader =
Record[Idx++];
6170 for (
unsigned N =
Record[Idx++]; N; --N) {
6171 std::string VFSOverlayFile = ReadString(
Record, Idx);
6178bool ASTReader::ParsePreprocessorOptions(
const RecordData &
Record,
6181 std::string &SuggestedPredefines) {
6186 bool ReadMacros =
Record[Idx++];
6188 for (
unsigned N =
Record[Idx++]; N; --N) {
6190 bool IsUndef =
Record[Idx++];
6191 PPOpts.
Macros.push_back(std::make_pair(Macro, IsUndef));
6196 for (
unsigned N =
Record[Idx++]; N; --N) {
6201 for (
unsigned N =
Record[Idx++]; N; --N) {
6210 SuggestedPredefines.clear();
6212 SuggestedPredefines);
6215std::pair<ModuleFile *, unsigned>
6216ASTReader::getModulePreprocessedEntity(
unsigned GlobalIndex) {
6217 GlobalPreprocessedEntityMapType::iterator
6218 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
6219 assert(I != GlobalPreprocessedEntityMap.end() &&
6220 "Corrupted global preprocessed entity map");
6223 return std::make_pair(M, LocalIndex);
6226llvm::iterator_range<PreprocessingRecord::iterator>
6227ASTReader::getModulePreprocessedEntities(
ModuleFile &Mod)
const {
6236bool ASTReader::canRecoverFromOutOfDate(StringRef ModuleFileName,
6237 unsigned int ClientLoadCapabilities) {
6238 return ClientLoadCapabilities & ARR_OutOfDate &&
6239 !getModuleManager().getModuleCache().isPCMFinal(ModuleFileName);
6242llvm::iterator_range<ASTReader::ModuleDeclIterator>
6244 return llvm::make_range(
6251 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
6252 assert(I != GlobalSkippedRangeMap.end() &&
6253 "Corrupted global skipped range map");
6256 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
6259 TranslateSourceLocation(*M, RawRange.
getEnd()));
6260 assert(Range.isValid());
6266 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6268 unsigned LocalIndex = PPInfo.second;
6271 if (!PP.getPreprocessingRecord()) {
6272 Error(
"no preprocessing record");
6279 Error(std::move(Err));
6286 Error(MaybeEntry.takeError());
6289 llvm::BitstreamEntry Entry = MaybeEntry.get();
6291 if (Entry.Kind != llvm::BitstreamEntry::Record)
6296 TranslateSourceLocation(M, PPOffs.
getEnd()));
6302 if (!MaybeRecType) {
6303 Error(MaybeRecType.takeError());
6308 bool isBuiltin =
Record[0];
6312 Name = getLocalIdentifier(M,
Record[1]);
6315 getGlobalPreprocessedEntityID(M,
Record[1]);
6316 Def = cast<MacroDefinitionRecord>(
6317 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
6335 if (DeserializationListener)
6336 DeserializationListener->MacroDefinitionRead(PPID, MD);
6342 const char *FullFileNameStart = Blob.data() +
Record[0];
6343 StringRef FullFileName(FullFileNameStart, Blob.size() -
Record[0]);
6345 if (!FullFileName.empty())
6346 File = PP.getFileManager().getOptionalFileRef(FullFileName);
6353 StringRef(Blob.data(),
Record[0]),
6361 llvm_unreachable(
"Invalid PreprocessorDetailRecordTypes");
6371 GlobalSLocOffsetMapType::const_iterator SLocMapI)
const {
6373 for (GlobalSLocOffsetMapType::const_iterator
6374 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
6380 return getTotalNumPreprocessedEntities();
6385struct PPEntityComp {
6415 bool EndsAfter)
const {
6416 if (SourceMgr.isLocalSourceLocation(Loc))
6417 return getTotalNumPreprocessedEntities();
6419 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
6420 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
6421 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
6422 "Corrupted global sloc offset map");
6424 if (SLocMapI->second->NumPreprocessedEntities == 0)
6425 return findNextPreprocessedEntity(SLocMapI);
6436 pp_iterator
First = pp_begin;
6440 PPI = std::upper_bound(pp_begin, pp_end, Loc,
6441 PPEntityComp(*
this, M));
6450 std::advance(PPI,
Half);
6451 if (SourceMgr.isBeforeInTranslationUnit(
6452 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
6455 Count = Count -
Half - 1;
6462 return findNextPreprocessedEntity(SLocMapI);
6469std::pair<unsigned, unsigned>
6471 if (Range.isInvalid())
6472 return std::make_pair(0,0);
6473 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
6476 findPreprocessedEntity(Range.getBegin(),
false);
6478 return std::make_pair(BeginID, EndID);
6488 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6490 unsigned LocalIndex = PPInfo.second;
6497 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
6506 class HeaderFileInfoVisitor {
6508 std::optional<HeaderFileInfo> HFI;
6511 explicit HeaderFileInfoVisitor(
FileEntryRef FE) : FE(FE) {}
6520 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
6521 if (Pos == Table->end())
6528 std::optional<HeaderFileInfo> getHeaderFileInfo()
const {
return HFI; }
6534 HeaderFileInfoVisitor Visitor(FE);
6535 ModuleMgr.visit(Visitor);
6536 if (std::optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
6543 using DiagState = DiagnosticsEngine::DiagState;
6554 auto ReadDiagState = [&](
const DiagState &BasedOn,
6555 bool IncludeNonPragmaStates) {
6556 unsigned BackrefID =
Record[Idx++];
6558 return DiagStates[BackrefID - 1];
6561 Diag.DiagStates.push_back(BasedOn);
6562 DiagState *NewState = &
Diag.DiagStates.back();
6563 DiagStates.push_back(NewState);
6564 unsigned Size =
Record[Idx++];
6565 assert(Idx + Size * 2 <=
Record.size() &&
6566 "Invalid data, not enough diag/map pairs");
6568 unsigned DiagID =
Record[Idx++];
6571 if (!NewMapping.
isPragma() && !IncludeNonPragmaStates)
6584 Mapping = NewMapping;
6590 DiagState *FirstState;
6595 FirstState =
Diag.DiagStatesByLoc.FirstDiagState;
6596 DiagStates.push_back(FirstState);
6600 "Invalid data, unexpected backref in initial state");
6602 assert(Idx <
Record.size() &&
6603 "Invalid data, not enough state change pairs in initial state");
6608 unsigned Flags =
Record[Idx++];
6610 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
6611 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
6612 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
6613 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
6614 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
6616 FirstState = ReadDiagState(Initial,
true);
6624 .StateTransitions.push_back({FirstState, 0});
6629 FirstState = ReadDiagState(*
Diag.DiagStatesByLoc.CurDiagState,
false);
6633 unsigned NumLocations =
Record[Idx++];
6634 while (NumLocations--) {
6635 assert(Idx <
Record.size() &&
6636 "Invalid data, missing pragma diagnostic states");
6638 assert(FID.
isValid() &&
"invalid FileID for transition");
6639 unsigned Transitions =
Record[Idx++];
6645 auto &F =
Diag.DiagStatesByLoc.Files[FID];
6646 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
6647 for (
unsigned I = 0; I != Transitions; ++I) {
6648 unsigned Offset =
Record[Idx++];
6649 auto *State = ReadDiagState(*FirstState,
false);
6650 F.StateTransitions.push_back({State, Offset});
6655 assert(Idx <
Record.size() &&
6656 "Invalid data, missing final pragma diagnostic state");
6658 auto *CurState = ReadDiagState(*FirstState,
false);
6661 Diag.DiagStatesByLoc.CurDiagState = CurState;
6662 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
6667 auto &
T =
Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
6669 T.push_back({CurState, 0});
6671 T[0].State = CurState;
6680ASTReader::RecordLocation ASTReader::TypeCursorForIndex(
unsigned Index) {
6681 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
6682 assert(I != GlobalTypeMap.end() &&
"Corrupted global type map");
6684 return RecordLocation(
6691#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
6692 case TYPE_##CODE_ID: return Type::CLASS_ID;
6693#include "clang/Serialization/TypeBitCodes.def"
6695 return std::nullopt;
6705QualType ASTReader::readTypeRecord(
unsigned Index) {
6706 assert(ContextObj &&
"reading type with no AST context");
6708 RecordLocation Loc = TypeCursorForIndex(Index);
6709 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
6715 ReadingKindTracker ReadingKind(Read_Type, *
this);
6718 Deserializing AType(
this);
6720 if (llvm::Error Err = DeclsCursor.JumpToBit(Loc.Offset)) {
6721 Error(std::move(Err));
6726 Error(RawCode.takeError());
6733 Error(Code.takeError());
6744 Error(
"Unexpected code for type");
6749 return TypeReader.read(*maybeClass);
6777 : Reader(Reader),
Seq(
Seq) {}
6782#define ABSTRACT_TYPELOC(CLASS, PARENT)
6783#define TYPELOC(CLASS, PARENT) \
6784 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6785#include "clang/AST/TypeLocNodes.def"
6851 if (Reader.readBool())
6858 VisitArrayTypeLoc(TL);
6862 VisitArrayTypeLoc(TL);
6866 VisitArrayTypeLoc(TL);
6869void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6871 VisitArrayTypeLoc(TL);
6874void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6882void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6891void TypeLocReader::VisitDependentVectorTypeLoc(
6907void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
6921 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i) {
6927 VisitFunctionTypeLoc(TL);
6931 VisitFunctionTypeLoc(TL);
6938void TypeLocReader::VisitUsingTypeLoc(
UsingTypeLoc TL) {
6976 auto NNS = readNestedNameSpecifierLoc();
6977 auto TemplateKWLoc = readSourceLocation();
6978 auto ConceptNameLoc = readDeclarationNameInfo();
6979 auto FoundDecl = readDeclAs<NamedDecl>();
6980 auto NamedConcept = readDeclAs<ConceptDecl>();
6982 getContext(), NNS, TemplateKWLoc, ConceptNameLoc, FoundDecl, NamedConcept,
6983 (readBool() ? readASTTemplateArgumentListInfo() :
nullptr));
6987void TypeLocReader::VisitAutoTypeLoc(
AutoTypeLoc TL) {
6989 if (Reader.readBool())
6991 if (Reader.readBool())
6995void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
7004void TypeLocReader::VisitEnumTypeLoc(
EnumTypeLoc TL) {
7024void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
7029void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
7034void TypeLocReader::VisitTemplateSpecializationTypeLoc(
7040 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
7042 Reader.readTemplateArgumentLocInfo(
7046void TypeLocReader::VisitParenTypeLoc(
ParenTypeLoc TL) {
7066void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
7074 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I)
7076 Reader.readTemplateArgumentLocInfo(
7120void TypeLocReader::VisitPipeTypeLoc(
PipeTypeLoc TL) {
7127void TypeLocReader::VisitDependentBitIntTypeLoc(
7144 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
7150 assert(ContextObj &&
"reading type with no AST context");
7161 llvm_unreachable(
"Invalid predefined type");
7347#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7348 case PREDEF_TYPE_##Id##_ID: \
7349 T = Context.SingletonId; \
7351#include "clang/Basic/OpenCLImageTypes.def"
7352#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7353 case PREDEF_TYPE_##Id##_ID: \
7354 T = Context.Id##Ty; \
7356#include "clang/Basic/OpenCLExtensionTypes.def"
7396#define SVE_TYPE(Name, Id, SingletonId) \
7397 case PREDEF_TYPE_##Id##_ID: \
7398 T = Context.SingletonId; \
7400#include "clang/Basic/AArch64SVEACLETypes.def"
7401#define PPC_VECTOR_TYPE(Name, Id, Size) \
7402 case PREDEF_TYPE_##Id##_ID: \
7403 T = Context.Id##Ty; \
7405#include "clang/Basic/PPCTypes.def"
7406#define RVV_TYPE(Name, Id, SingletonId) \
7407 case PREDEF_TYPE_##Id##_ID: \
7408 T = Context.SingletonId; \
7410#include "clang/Basic/RISCVVTypes.def"
7411#define WASM_TYPE(Name, Id, SingletonId) \
7412 case PREDEF_TYPE_##Id##_ID: \
7413 T = Context.SingletonId; \
7415#include "clang/Basic/WebAssemblyReferenceTypes.def"
7418 assert(!
T.isNull() &&
"Unknown predefined type");
7419 return T.withFastQualifiers(FastQuals);
7423 assert(Index < TypesLoaded.size() &&
"Type index out-of-range");
7424 if (TypesLoaded[Index].isNull()) {
7425 TypesLoaded[Index] = readTypeRecord(Index);
7426 if (TypesLoaded[Index].isNull())
7429 TypesLoaded[Index]->setFromAST();
7430 if (DeserializationListener)
7432 TypesLoaded[Index]);
7435 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7439 return GetType(getGlobalTypeID(F, LocalID));
7451 ReadModuleOffsetMap(F);
7455 assert(I != F.
TypeRemap.
end() &&
"Invalid index into type index remap");
7457 unsigned GlobalIndex = LocalIndex + I->second;
7467 return readTypeSourceInfo();
7470 readNestedNameSpecifierLoc();
7480 TemplateNameLoc, EllipsisLoc);
7491 llvm_unreachable(
"unexpected template argument loc");
7506 Result.setLAngleLoc(readSourceLocation());
7507 Result.setRAngleLoc(readSourceLocation());
7508 unsigned NumArgsAsWritten = readInt();
7509 for (
unsigned i = 0; i != NumArgsAsWritten; ++i)
7510 Result.addArgument(readTemplateArgumentLoc());
7516 readTemplateArgumentListInfo(
Result);
7525 if (NumCurrentElementsDeserializing) {
7530 PendingIncompleteDeclChains.push_back(
const_cast<Decl*
>(D));
7535 assert(isa<TranslationUnitDecl>(D) &&
"Not a TU?");
7546 if (isa<TranslationUnitDecl, NamespaceDecl, RecordDecl, EnumDecl>(DC)) {
7548 if (!getContext().getLangOpts().
CPlusPlus &&
7549 isa<TranslationUnitDecl>(DC)) {
7553 auto *II = Name.getAsIdentifierInfo();
7554 assert(II &&
"non-identifier name in C?");
7555 if (II->isOutOfDate())
7556 updateOutOfDateIdentifier(*II);
7562 auto *DC = cast<DeclContext>(DCDecl);
7564 FindExternalLexicalDecls(
7570 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7571 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7572 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7573 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7574 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
7575 if (
auto *Template = FD->getPrimaryTemplate())
7576 Template->LoadLazySpecializations();
7582 RecordLocation Loc = getLocalBitOffset(Offset);
7583 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7585 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7586 Error(std::move(Err));
7589 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7594 Error(MaybeCode.takeError());
7597 unsigned Code = MaybeCode.get();
7601 if (!MaybeRecCode) {
7602 Error(MaybeRecCode.takeError());
7606 Error(
"malformed AST file: missing C++ ctor initializers");
7610 return Record.readCXXCtorInitializers();
7614 assert(ContextObj &&
"reading base specifiers with no AST context");
7617 RecordLocation Loc = getLocalBitOffset(Offset);
7618 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7620 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7621 Error(std::move(Err));
7624 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7629 Error(MaybeCode.takeError());
7632 unsigned Code = MaybeCode.get();
7636 if (!MaybeRecCode) {
7637 Error(MaybeCode.takeError());
7640 unsigned RecCode = MaybeRecCode.get();
7643 Error(
"malformed AST file: missing C++ base specifiers");
7647 unsigned NumBases =
Record.readInt();
7650 for (
unsigned I = 0; I != NumBases; ++I)
7651 Bases[I] =
Record.readCXXBaseSpecifier();
7662 ReadModuleOffsetMap(F);
7666 assert(I != F.
DeclRemap.
end() &&
"Invalid index into decl index remap");
7686 assert(I != GlobalDeclMap.end() &&
"Corrupted global declaration map");
7696 if (Index > DeclsLoaded.size()) {
7697 Error(
"declaration ID out-of-range for AST file");
7701 if (
Decl *D = DeclsLoaded[Index])
7702 return D->getLocation();
7705 DeclCursorForID(ID, Loc);
7765 llvm_unreachable(
"PredefinedDeclIDs unknown enum value");
7769 assert(ContextObj &&
"reading decl with no AST context");
7777 Merged.push_back(ID);
7784 if (Index >= DeclsLoaded.size()) {
7785 assert(0 &&
"declaration ID out-of-range for AST file");
7786 Error(
"declaration ID out-of-range for AST file");
7790 return DeclsLoaded[Index];
7795 return GetExistingDecl(ID);
7799 if (Index >= DeclsLoaded.size()) {
7800 assert(0 &&
"declaration ID out-of-range for AST file");
7801 Error(
"declaration ID out-of-range for AST file");
7805 if (!DeclsLoaded[Index]) {
7807 if (DeserializationListener)
7808 DeserializationListener->DeclRead(ID.get(), DeclsLoaded[Index]);
7811 return DeclsLoaded[Index];
7821 assert(I != GlobalDeclMap.end() &&
"Corrupted global declaration map");
7824 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7834 if (Idx >=
Record.size()) {
7835 Error(
"Corrupted AST file");
7849 ClearSwitchCaseIDs();
7852 RecordLocation Loc = getLocalBitOffset(Offset);
7853 if (llvm::Error Err = Loc.F->DeclsCursor.JumpToBit(Loc.Offset)) {
7854 Error(std::move(Err));
7857 assert(NumCurrentElementsDeserializing == 0 &&
7858 "should not be called while already deserializing");
7860 return ReadStmtFromStream(*Loc.F);
7869 assert(LexicalDecls.size() % 2 == 0 &&
"expected an even number of entries");
7870 for (
int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7872 if (!IsKindWeWant(K))
7880 if (PredefsVisited[ID])
7883 PredefsVisited[ID] =
true;
7887 assert(D->getKind() == K &&
"wrong kind for lexical decl");
7894 if (isa<TranslationUnitDecl>(DC)) {
7895 for (
const auto &Lexical : TULexicalDecls)
7896 Visit(Lexical.first, Lexical.second);
7898 auto I = LexicalDecls.find(DC);
7899 if (I != LexicalDecls.end())
7900 Visit(I->second.first, I->second.second);
7903 ++NumLexicalDeclContextsRead;
7940 unsigned Offset,
unsigned Length,
7944 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(
File);
7945 if (I == FileDeclIDs.end())
7948 FileDeclsInfo &DInfo = I->second;
7949 if (DInfo.Decls.empty())
7953 BeginLoc =
SM.getLocForStartOfFile(
File).getLocWithOffset(Offset);
7956 DeclIDComp DIDComp(*
this, *DInfo.Mod);
7958 llvm::lower_bound(DInfo.Decls, BeginLoc, DIDComp);
7959 if (BeginIt != DInfo.Decls.begin())
7965 while (BeginIt != DInfo.Decls.begin() &&
7966 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7967 ->isTopLevelDeclInObjCContainer())
7971 llvm::upper_bound(DInfo.Decls, EndLoc, DIDComp);
7972 if (EndIt != DInfo.Decls.end())
7976 DIt = BeginIt; DIt != EndIt; ++DIt)
7977 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7984 "DeclContext has no visible decls in storage");
7988 auto It = Lookups.find(DC);
7989 if (It == Lookups.end())
7998 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7999 if (ND->
getDeclName() == Name && Found.insert(ND).second)
8000 Decls.push_back(ND);
8003 ++NumVisibleDeclContextsRead;
8004 SetExternalVisibleDeclsForName(DC, Name, Decls);
8005 return !Decls.empty();
8012 auto It = Lookups.find(DC);
8013 assert(It != Lookups.end() &&
8014 "have external visible storage but no lookup tables");
8019 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
8023 ++NumVisibleDeclContextsRead;
8025 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
8026 SetExternalVisibleDeclsForName(DC, I->first, I->second);
8028 const_cast<DeclContext *
>(DC)->setHasExternalVisibleStorage(
false);
8033 auto I = Lookups.find(Primary);
8034 return I == Lookups.end() ? nullptr : &I->second;
8043 assert(ImplD && Consumer);
8045 for (
auto *I : ImplD->
methods())
8051void ASTReader::PassInterestingDeclToConsumer(
Decl *D) {
8059 this->Consumer = Consumer;
8062 PassInterestingDeclsToConsumer();
8064 if (DeserializationListener)
8065 DeserializationListener->ReaderInitialized(
this);
8069 std::fprintf(stderr,
"*** AST File Statistics:\n");
8071 unsigned NumTypesLoaded =
8072 TypesLoaded.size() - llvm::count(TypesLoaded.materialized(),
QualType());
8073 unsigned NumDeclsLoaded =
8074 DeclsLoaded.size() -
8075 llvm::count(DeclsLoaded.materialized(), (
Decl *)
nullptr);
8076 unsigned NumIdentifiersLoaded =
8077 IdentifiersLoaded.size() -
8079 unsigned NumMacrosLoaded =
8080 MacrosLoaded.size() - llvm::count(MacrosLoaded, (
MacroInfo *)
nullptr);
8081 unsigned NumSelectorsLoaded =
8082 SelectorsLoaded.size() - llvm::count(SelectorsLoaded,
Selector());
8084 if (
unsigned TotalNumSLocEntries = getTotalNumSLocs())
8085 std::fprintf(stderr,
" %u/%u source location entries read (%f%%)\n",
8086 NumSLocEntriesRead, TotalNumSLocEntries,
8087 ((
float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
8088 if (!TypesLoaded.empty())
8089 std::fprintf(stderr,
" %u/%u types read (%f%%)\n",
8090 NumTypesLoaded, (
unsigned)TypesLoaded.size(),
8091 ((
float)NumTypesLoaded/TypesLoaded.size() * 100));
8092 if (!DeclsLoaded.empty())
8093 std::fprintf(stderr,
" %u/%u declarations read (%f%%)\n",
8094 NumDeclsLoaded, (
unsigned)DeclsLoaded.size(),
8095 ((
float)NumDeclsLoaded/DeclsLoaded.size() * 100));
8096 if (!IdentifiersLoaded.empty())
8097 std::fprintf(stderr,
" %u/%u identifiers read (%f%%)\n",
8098 NumIdentifiersLoaded, (
unsigned)IdentifiersLoaded.size(),
8099 ((
float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
8100 if (!MacrosLoaded.empty())
8101 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8102 NumMacrosLoaded, (
unsigned)MacrosLoaded.size(),
8103 ((
float)NumMacrosLoaded/MacrosLoaded.size() * 100));
8104 if (!SelectorsLoaded.empty())
8105 std::fprintf(stderr,
" %u/%u selectors read (%f%%)\n",
8106 NumSelectorsLoaded, (
unsigned)SelectorsLoaded.size(),
8107 ((
float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
8108 if (TotalNumStatements)
8109 std::fprintf(stderr,
" %u/%u statements read (%f%%)\n",
8110 NumStatementsRead, TotalNumStatements,
8111 ((
float)NumStatementsRead/TotalNumStatements * 100));
8113 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8114 NumMacrosRead, TotalNumMacros,
8115 ((
float)NumMacrosRead/TotalNumMacros * 100));
8116 if (TotalLexicalDeclContexts)
8117 std::fprintf(stderr,
" %u/%u lexical declcontexts read (%f%%)\n",
8118 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
8119 ((
float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
8121 if (TotalVisibleDeclContexts)
8122 std::fprintf(stderr,
" %u/%u visible declcontexts read (%f%%)\n",
8123 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
8124 ((
float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
8126 if (TotalNumMethodPoolEntries)
8127 std::fprintf(stderr,
" %u/%u method pool entries read (%f%%)\n",
8128 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
8129 ((
float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
8131 if (NumMethodPoolLookups)
8132 std::fprintf(stderr,
" %u/%u method pool lookups succeeded (%f%%)\n",
8133 NumMethodPoolHits, NumMethodPoolLookups,
8134 ((
float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
8135 if (NumMethodPoolTableLookups)
8136 std::fprintf(stderr,
" %u/%u method pool table lookups succeeded (%f%%)\n",
8137 NumMethodPoolTableHits, NumMethodPoolTableLookups,
8138 ((
float)NumMethodPoolTableHits/NumMethodPoolTableLookups
8140 if (NumIdentifierLookupHits)
8141 std::fprintf(stderr,
8142 " %u / %u identifier table lookups succeeded (%f%%)\n",
8143 NumIdentifierLookupHits, NumIdentifierLookups,
8144 (
double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
8147 std::fprintf(stderr,
"\n");
8148 GlobalIndex->printStats();
8151 std::fprintf(stderr,
"\n");
8153 std::fprintf(stderr,
"\n");
8156template<
typename Key,
typename ModuleFile,
unsigned InitialCapacity>
8157LLVM_DUMP_METHOD
static void
8160 InitialCapacity> &Map) {
8161 if (Map.begin() == Map.end())
8166 llvm::errs() << Name <<
":\n";
8167 for (
typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
8170 if constexpr (std::is_integral_v<Key>)
8173 ID = I->first.get();
8174 llvm::errs() <<
" " << ID <<
" -> " << I->second->FileName <<
"\n";
8179 llvm::errs() <<
"*** PCH/ModuleFile Remappings:\n";
8181 dumpModuleIDMap(
"Global source location entry map", GlobalSLocEntryMap);
8189 GlobalPreprocessedEntityMap);
8191 llvm::errs() <<
"\n*** PCH/Modules Loaded:";
8200 if (llvm::MemoryBuffer *buf = I.Buffer) {
8201 size_t bytes = buf->getBufferSize();
8202 switch (buf->getBufferKind()) {
8203 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
8206 case llvm::MemoryBuffer::MemoryBuffer_MMap:
8221 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
8224 PreloadedDeclIDs.clear();
8227 if (!FPPragmaOptions.empty()) {
8228 assert(FPPragmaOptions.size() == 1 &&
"Wrong number of FP_PRAGMA_OPTIONS");
8231 SemaObj->CurFPFeatures =
8235 SemaObj->OpenCLFeatures = OpenCLExtensions;
8241 assert(SemaObj &&
"no Sema to update");
8245 if (!SemaDeclRefs.empty()) {
8246 assert(SemaDeclRefs.size() % 3 == 0);
8247 for (
unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
8248 if (!SemaObj->StdNamespace)
8249 SemaObj->StdNamespace = SemaDeclRefs[I].get();
8250 if (!SemaObj->StdBadAlloc)
8251 SemaObj->StdBadAlloc = SemaDeclRefs[I + 1].get();
8252 if (!SemaObj->StdAlignValT)
8253 SemaObj->StdAlignValT = SemaDeclRefs[I + 2].get();
8255 SemaDeclRefs.clear();
8260 if(OptimizeOffPragmaLocation.isValid())
8261 SemaObj->ActOnPragmaOptimize(
false, OptimizeOffPragmaLocation);
8262 if (PragmaMSStructState != -1)
8264 if (PointersToMembersPragmaLocation.isValid()) {
8265 SemaObj->ActOnPragmaMSPointersToMembers(
8267 PragmaMSPointersToMembersState,
8268 PointersToMembersPragmaLocation);
8270 SemaObj->CUDA().ForceHostDeviceDepth = ForceHostDeviceDepth;
8272 if (PragmaAlignPackCurrentValue) {
8276 bool DropFirst =
false;
8277 if (!PragmaAlignPackStack.empty() &&
8278 PragmaAlignPackStack.front().Location.isInvalid()) {
8279 assert(PragmaAlignPackStack.front().Value ==
8280 SemaObj->AlignPackStack.DefaultValue &&
8281 "Expected a default alignment value");
8282 SemaObj->AlignPackStack.Stack.emplace_back(
8283 PragmaAlignPackStack.front().SlotLabel,
8284 SemaObj->AlignPackStack.CurrentValue,
8285 SemaObj->AlignPackStack.CurrentPragmaLocation,
8286 PragmaAlignPackStack.front().PushLocation);
8289 for (
const auto &Entry :
8290 llvm::ArrayRef(PragmaAlignPackStack).drop_front(DropFirst ? 1 : 0)) {
8291 SemaObj->AlignPackStack.Stack.emplace_back(
8292 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8294 if (PragmaAlignPackCurrentLocation.isInvalid()) {
8295 assert(*PragmaAlignPackCurrentValue ==
8296 SemaObj->AlignPackStack.DefaultValue &&
8297 "Expected a default align and pack value");
8300 SemaObj->AlignPackStack.CurrentValue = *PragmaAlignPackCurrentValue;
8301 SemaObj->AlignPackStack.CurrentPragmaLocation =
8302 PragmaAlignPackCurrentLocation;
8305 if (FpPragmaCurrentValue) {
8309 bool DropFirst =
false;
8310 if (!FpPragmaStack.empty() && FpPragmaStack.front().Location.isInvalid()) {
8311 assert(FpPragmaStack.front().Value ==
8312 SemaObj->FpPragmaStack.DefaultValue &&
8313 "Expected a default pragma float_control value");
8314 SemaObj->FpPragmaStack.Stack.emplace_back(
8315 FpPragmaStack.front().SlotLabel, SemaObj->FpPragmaStack.CurrentValue,
8316 SemaObj->FpPragmaStack.CurrentPragmaLocation,
8317 FpPragmaStack.front().PushLocation);
8320 for (
const auto &Entry :
8322 SemaObj->FpPragmaStack.Stack.emplace_back(
8323 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8324 if (FpPragmaCurrentLocation.isInvalid()) {
8325 assert(*FpPragmaCurrentValue == SemaObj->FpPragmaStack.DefaultValue &&
8326 "Expected a default pragma float_control value");
8329 SemaObj->FpPragmaStack.CurrentValue = *FpPragmaCurrentValue;
8330 SemaObj->FpPragmaStack.CurrentPragmaLocation = FpPragmaCurrentLocation;
8335 for (
auto &Import : PendingImportedModulesSema) {
8336 if (Import.ImportLoc.isInvalid())
8338 if (
Module *Imported = getSubmodule(Import.ID)) {
8339 SemaObj->makeModuleVisible(Imported, Import.ImportLoc);
8342 PendingImportedModulesSema.clear();
8349 IdentifierLookupVisitor Visitor(Name, 0,
8350 NumIdentifierLookups,
8351 NumIdentifierLookupHits);
8357 if (PP.getLangOpts().CPlusPlus) {
8358 for (
auto *F : ModuleMgr.pch_modules())
8366 if (!loadGlobalIndex()) {
8367 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
8372 ModuleMgr.visit(Visitor, HitsPtr);
8376 markIdentifierUpToDate(II);
8394 ASTIdentifierLookupTable::key_iterator Current;
8398 ASTIdentifierLookupTable::key_iterator End;
8405 bool SkipModules =
false);
8407 StringRef Next()
override;
8414 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8418 while (Current == End) {
8430 Current = IdTable->key_begin();
8431 End = IdTable->key_end();
8436 StringRef
Result = *Current;
8445 std::unique_ptr<IdentifierIterator> Current;
8446 std::unique_ptr<IdentifierIterator> Queued;
8449 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator>
First,
8450 std::unique_ptr<IdentifierIterator> Second)
8451 : Current(
std::move(
First)), Queued(
std::move(Second)) {}
8453 StringRef Next()
override {
8457 StringRef result = Current->Next();
8458 if (!result.empty())
8463 std::swap(Current, Queued);
8472 std::unique_ptr<IdentifierIterator> ReaderIter(
8474 std::unique_ptr<IdentifierIterator> ModulesIter(
8475 GlobalIndex->createIdentifierIterator());
8476 return new ChainedIdentifierIterator(std::move(ReaderIter),
8477 std::move(ModulesIter));
8484namespace serialization {
8489 unsigned PriorGeneration;
8490 unsigned InstanceBits = 0;
8491 unsigned FactoryBits = 0;
8492 bool InstanceHasMoreThanOneDecl =
false;
8493 bool FactoryHasMoreThanOneDecl =
false;
8499 unsigned PriorGeneration)
8500 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8510 ++Reader.NumMethodPoolTableLookups;
8513 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8514 if (Pos == PoolTable->end())
8517 ++Reader.NumMethodPoolTableHits;
8518 ++Reader.NumSelectorsRead;
8522 ++Reader.NumMethodPoolEntriesRead;
8524 if (Reader.DeserializationListener)
8530 InstanceMethods.append(
Data.Instance.rbegin(),
Data.Instance.rend());
8531 FactoryMethods.append(
Data.Factory.rbegin(),
Data.Factory.rend());
8532 InstanceBits =
Data.InstanceBits;
8533 FactoryBits =
Data.FactoryBits;
8534 InstanceHasMoreThanOneDecl =
Data.InstanceHasMoreThanOneDecl;
8535 FactoryHasMoreThanOneDecl =
Data.FactoryHasMoreThanOneDecl;
8541 return InstanceMethods;
8546 return FactoryMethods;
8553 return InstanceHasMoreThanOneDecl;
8571 unsigned &Generation = SelectorGeneration[Sel];
8572 unsigned PriorGeneration = Generation;
8574 SelectorOutOfDate[Sel] =
false;
8577 ++NumMethodPoolLookups;
8579 ModuleMgr.
visit(Visitor);
8585 ++NumMethodPoolHits;
8608 if (SelectorOutOfDate[Sel])
8616 for (
unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8618 = dyn_cast_or_null<NamespaceDecl>(
GetDecl(KnownNamespaces[I])))
8619 Namespaces.push_back(Namespace);
8624 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8625 for (
unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8626 UndefinedButUsedDecl &
U = UndefinedButUsed[Idx++];
8629 Undefined.insert(std::make_pair(D, Loc));
8631 UndefinedButUsed.clear();
8637 for (
unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8640 uint64_t Count = DelayedDeleteExprs[Idx++];
8641 for (uint64_t
C = 0;
C < Count; ++
C) {
8644 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8645 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8652 for (
unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8653 VarDecl *Var = dyn_cast_or_null<VarDecl>(
GetDecl(TentativeDefinitions[I]));
8655 TentativeDefs.push_back(Var);
8657 TentativeDefinitions.clear();
8662 for (
unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8664 = dyn_cast_or_null<DeclaratorDecl>(
GetDecl(UnusedFileScopedDecls[I]));
8668 UnusedFileScopedDecls.clear();
8673 for (
unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8675 = dyn_cast_or_null<CXXConstructorDecl>(
GetDecl(DelegatingCtorDecls[I]));
8679 DelegatingCtorDecls.clear();
8683 for (
unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8685 = dyn_cast_or_null<TypedefNameDecl>(
GetDecl(ExtVectorDecls[I]));
8689 ExtVectorDecls.clear();
8694 for (
unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8697 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8701 UnusedLocalTypedefNameCandidates.clear();
8706 for (
auto I : DeclsToCheckForDeferredDiags) {
8707 auto *D = dyn_cast_or_null<Decl>(
GetDecl(I));
8711 DeclsToCheckForDeferredDiags.clear();
8716 if (ReferencedSelectorsData.empty())
8721 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8723 while (I < DataSize) {
8727 Sels.push_back(std::make_pair(Sel, SelLoc));
8729 ReferencedSelectorsData.clear();
8734 if (WeakUndeclaredIdentifiers.empty())
8737 for (
unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; ) {
8745 WeakIDs.push_back(std::make_pair(WeakId, WI));
8747 WeakUndeclaredIdentifiers.clear();
8751 for (
unsigned Idx = 0, N = VTableUses.size(); Idx < N; ) {
8753 VTableUse &TableInfo = VTableUses[Idx++];
8754 VT.
Record = dyn_cast_or_null<CXXRecordDecl>(
GetDecl(TableInfo.ID));
8757 VTables.push_back(VT);
8765 for (
unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8766 PendingInstantiation &Inst = PendingInstantiations[Idx++];
8770 Pending.push_back(std::make_pair(D, Loc));
8772 PendingInstantiations.clear();
8776 llvm::MapVector<
const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8778 for (
auto &LPT : LateParsedTemplates) {
8781 for (
unsigned Idx = 0, N = LateParsed.size(); Idx < N;
8786 auto LT = std::make_unique<LateParsedTemplate>();
8791 assert(F &&
"No module");
8793 unsigned TokN = LateParsed[Idx++];
8794 LT->Toks.reserve(TokN);
8795 for (
unsigned T = 0;
T < TokN; ++
T)
8796 LT->Toks.push_back(
ReadToken(*F, LateParsed, Idx));
8798 LPTMap.insert(std::make_pair(FD, std::move(
LT)));
8802 LateParsedTemplates.clear();
8809 LambdaDeclarationsForMerging.insert(
8822 assert(ID &&
"Non-zero identifier ID required");
8823 assert(ID <= IdentifiersLoaded.size() &&
"identifier ID out of range");
8824 IdentifiersLoaded[ID - 1] = II;
8825 if (DeserializationListener)
8848 if (NumCurrentElementsDeserializing && !Decls) {
8849 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8853 for (
unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8866 Decls->push_back(D);
8873 pushExternalDeclIntoScope(D, II);
8881 if (IdentifiersLoaded.empty()) {
8882 Error(
"no identifier table in AST file");
8887 if (!IdentifiersLoaded[ID]) {
8889 assert(I != GlobalIdentifierMap.
end() &&
"Corrupted global identifier map");
8892 const unsigned char *
Data =
8899 IdentifiersLoaded[ID] = &II;
8901 if (DeserializationListener)
8905 return IdentifiersLoaded[ID];
8917 ReadModuleOffsetMap(M);
8922 &&
"Invalid index into identifier index remap");
8924 return LocalID + I->second;
8931 if (MacrosLoaded.empty()) {
8932 Error(
"no macro table in AST file");
8937 if (!MacrosLoaded[ID]) {
8940 assert(I != GlobalMacroMap.
end() &&
"Corrupted global macro map");
8946 if (DeserializationListener)
8951 return MacrosLoaded[ID];
8959 ReadModuleOffsetMap(M);
8963 assert(I != M.
MacroRemap.
end() &&
"Invalid index into macro index remap");
8965 return LocalID + I->second;
8974 ReadModuleOffsetMap(M);
8979 &&
"Invalid index into submodule index remap");
8981 return LocalID + I->second;
8986 assert(GlobalID == 0 &&
"Unhandled global submodule ID");
8990 if (GlobalID > SubmodulesLoaded.size()) {
8991 Error(
"submodule ID out of range in AST file");
9006 return I == GlobalSubmoduleMap.
end() ? nullptr : I->second;
9009 unsigned IndexFromEnd = ID >> 1;
9010 assert(IndexFromEnd &&
"got reference to unknown module file");
9027 auto I = llvm::find(PCHModules, M);
9028 assert(I != PCHModules.end() &&
"emitting reference to unknown file");
9029 return (I - PCHModules.end()) << 1;
9039 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
9044 llvm::sys::path::parent_path(MF.
FileName),
9047 return std::nullopt;
9051 auto I = DefinitionSource.find(FD);
9052 if (I == DefinitionSource.end())
9065 if (ID > SelectorsLoaded.size()) {
9066 Error(
"selector ID out of range in AST file");
9070 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() ==
nullptr) {
9073 assert(I != GlobalSelectorMap.
end() &&
"Corrupted global selector map");
9077 SelectorsLoaded[ID - 1] =
9079 if (DeserializationListener)
9080 DeserializationListener->
SelectorRead(ID, SelectorsLoaded[ID - 1]);
9083 return SelectorsLoaded[ID - 1];
9101 ReadModuleOffsetMap(M);
9106 &&
"Invalid index into selector index remap");
9108 return LocalID + I->second;
9113 switch (Name.getNameKind()) {
9139 NameInfo.
setName(readDeclarationName());
9151 unsigned NumTPLists =
readInt();
9156 for (
unsigned i = 0; i != NumTPLists; ++i)
9167 unsigned NumParams =
readInt();
9169 Params.reserve(NumParams);
9171 Params.push_back(readDeclAs<NamedDecl>());
9173 bool HasRequiresClause =
readBool();
9174 Expr *RequiresClause = HasRequiresClause ?
readExpr() :
nullptr;
9177 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
9178 return TemplateParams;
9183 bool Canonicalize) {
9184 unsigned NumTemplateArgs =
readInt();
9185 TemplArgs.reserve(NumTemplateArgs);
9186 while (NumTemplateArgs--)
9192 unsigned NumDecls =
readInt();
9194 while (NumDecls--) {
9206 bool inheritConstructors =
readBool();
9212 Result.setInheritConstructors(inheritConstructors);
9219 unsigned NumInitializers =
readInt();
9220 assert(NumInitializers &&
"wrote ctor initializers but have no inits");
9222 for (
unsigned i = 0; i != NumInitializers; ++i) {
9224 bool IsBaseVirtual =
false;
9240 Member = readDeclAs<FieldDecl>();
9244 IndirectMember = readDeclAs<IndirectFieldDecl>();
9255 BOMInit =
new (Context)
9257 RParenLoc, MemberOrEllipsisLoc);
9259 BOMInit =
new (Context)
9262 BOMInit =
new (Context)
9266 BOMInit =
new (Context)
9268 LParenLoc,
Init, RParenLoc);
9271 unsigned SourceOrder =
readInt();
9275 CtorInitializers[i] = BOMInit;
9278 return CtorInitializers;
9286 for (
unsigned I = 0; I != N; ++I) {
9287 auto Kind = readNestedNameSpecifierKind();
9292 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9299 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9306 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9319 Builder.Extend(Context,
9321 T->getTypeLoc(), ColonColonLoc);
9327 Builder.MakeGlobal(Context, ColonColonLoc);
9334 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9340 return Builder.getWithLocInContext(Context);
9351 const StringRef Blob) {
9352 unsigned Count =
Record[0];
9353 const char *Byte = Blob.data();
9354 llvm::BitVector Ret = llvm::BitVector(Count,
false);
9355 for (
unsigned I = 0; I < Count; ++Byte)
9356 for (
unsigned Bit = 0; Bit < 8 && I < Count; ++Bit, ++I)
9357 if (*Byte & (1 << Bit))
9369 unsigned Len =
Record[Idx++];
9385 if (!BaseDirectory.empty())
9392 unsigned Major =
Record[Idx++];
9393 unsigned Minor =
Record[Idx++];
9394 unsigned Subminor =
Record[Idx++];
9396 return VersionTuple(Major);
9398 return VersionTuple(Major, Minor - 1);
9399 return VersionTuple(Major, Minor - 1, Subminor - 1);
9410 return Diag(CurrentImportLoc, DiagID);
9414 return Diags.
Report(Loc, DiagID);
9426 assert((*CurrSwitchCaseStmts)[ID] ==
nullptr &&
9427 "Already have a SwitchCase with this ID");
9428 (*CurrSwitchCaseStmts)[ID] = SC;
9433 assert((*CurrSwitchCaseStmts)[ID] !=
nullptr &&
"No SwitchCase with this ID");
9434 return (*CurrSwitchCaseStmts)[ID];
9438 CurrSwitchCaseStmts->clear();
9443 std::vector<RawComment *> Comments;
9450 BitstreamCursor &Cursor = I->first;
9457 Cursor.advanceSkippingSubblocks(
9458 BitstreamCursor::AF_DontPopBlockAtEnd);
9460 Error(MaybeEntry.takeError());
9463 llvm::BitstreamEntry Entry = MaybeEntry.get();
9465 switch (Entry.Kind) {
9466 case llvm::BitstreamEntry::SubBlock:
9467 case llvm::BitstreamEntry::Error:
9468 Error(
"malformed block record in AST file");
9470 case llvm::BitstreamEntry::EndBlock:
9472 case llvm::BitstreamEntry::Record:
9480 if (!MaybeComment) {
9481 Error(MaybeComment.takeError());
9490 bool IsTrailingComment =
Record[Idx++];
9491 bool IsAlmostTrailingComment =
Record[Idx++];
9493 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9499 llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
9500 FileToOffsetToComment;
9504 std::pair<FileID, unsigned> Loc =
9506 if (Loc.first.isValid())
9507 Context.
Comments.OrderedComments[Loc.first].emplace(Loc.second,
C);
9520 assert(NumUserInputs <= NumInputs);
9521 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9522 for (
unsigned I = 0; I < N; ++I) {
9523 bool IsSystem = I >= NumUserInputs;
9525 Visitor(IFI, IsSystem);
9530 bool IncludeSystem,
bool Complain,
9532 bool isSystem)> Visitor) {
9535 assert(NumUserInputs <= NumInputs);
9536 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9537 for (
unsigned I = 0; I < N; ++I) {
9538 bool IsSystem = I >= NumUserInputs;
9539 InputFile IF = getInputFile(MF, I+1, Complain);
9540 Visitor(IF, IsSystem);
9548 for (
unsigned I = 0; I < NumInputs; ++I) {
9551 if (
auto FE = getInputFile(MF, I + 1).getFile())
9556void ASTReader::finishPendingActions() {
9558 !PendingIdentifierInfos.empty() || !PendingDeducedFunctionTypes.empty() ||
9559 !PendingDeducedVarTypes.empty() || !PendingIncompleteDeclChains.empty() ||
9560 !PendingDeclChains.empty() || !PendingMacroIDs.empty() ||
9561 !PendingDeclContextInfos.empty() || !PendingUpdateRecords.empty() ||
9562 !PendingObjCExtensionIvarRedeclarations.empty()) {
9565 using TopLevelDeclsMap =
9566 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9567 TopLevelDeclsMap TopLevelDecls;
9569 while (!PendingIdentifierInfos.empty()) {
9572 std::move(PendingIdentifierInfos.back().second);
9573 PendingIdentifierInfos.pop_back();
9580 for (
unsigned I = 0; I != PendingDeducedFunctionTypes.size(); ++I) {
9581 auto *FD = PendingDeducedFunctionTypes[I].first;
9582 FD->setType(
GetType(PendingDeducedFunctionTypes[I].second));
9584 if (
auto *DT = FD->getReturnType()->getContainedDeducedType()) {
9587 if (DT->isDeduced()) {
9588 PendingDeducedTypeUpdates.insert(
9589 {FD->getCanonicalDecl(), FD->getReturnType()});
9596 PendingUndeducedFunctionDecls.push_back(FD);
9600 PendingDeducedFunctionTypes.clear();
9604 for (
unsigned I = 0; I != PendingDeducedVarTypes.size(); ++I) {
9605 auto *VD = PendingDeducedVarTypes[I].first;
9606 VD->setType(
GetType(PendingDeducedVarTypes[I].second));
9608 PendingDeducedVarTypes.clear();
9612 for (
unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9613 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9615 PendingIncompleteDeclChains.clear();
9618 for (
unsigned I = 0; I != PendingDeclChains.size(); ++I)
9619 loadPendingDeclChain(PendingDeclChains[I].first,
9620 PendingDeclChains[I].second);
9621 PendingDeclChains.clear();
9624 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9625 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9627 for (
unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9628 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9633 for (
unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9636 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9638 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9640 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9641 if (!Info.M->isModule())
9645 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9647 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9648 if (Info.M->isModule())
9652 PendingMacroIDs.clear();
9656 while (!PendingDeclContextInfos.empty()) {
9657 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9658 PendingDeclContextInfos.pop_front();
9661 Info.D->setDeclContextsImpl(SemaDC, LexicalDC,
getContext());
9665 while (!PendingUpdateRecords.empty()) {
9666 auto Update = PendingUpdateRecords.pop_back_val();
9667 ReadingKindTracker ReadingKind(Read_Decl, *
this);
9668 loadDeclUpdateRecords(
Update);
9671 while (!PendingObjCExtensionIvarRedeclarations.empty()) {
9672 auto ExtensionsPair = PendingObjCExtensionIvarRedeclarations.back().first;
9673 auto DuplicateIvars =
9674 PendingObjCExtensionIvarRedeclarations.back().second;
9677 ExtensionsPair.first->getASTContext(),
9678 ExtensionsPair.second->getASTContext(), NonEquivalentDecls,
9682 if (Ctx.IsEquivalent(ExtensionsPair.first, ExtensionsPair.second)) {
9684 for (
auto IvarPair : DuplicateIvars) {
9685 ObjCIvarDecl *Ivar = IvarPair.first, *PrevIvar = IvarPair.second;
9687 Ivar->setDeclContextsImpl(PrevIvar->getDeclContext(),
9693 ExtensionsPair.first->setInvalidDecl();
9694 ExtensionsPair.second->getClassInterface()
9696 ->setIvarList(
nullptr);
9698 for (
auto IvarPair : DuplicateIvars) {
9699 Diag(IvarPair.first->getLocation(),
9700 diag::err_duplicate_ivar_declaration)
9701 << IvarPair.first->getIdentifier();
9702 Diag(IvarPair.second->getLocation(), diag::note_previous_definition);
9705 PendingObjCExtensionIvarRedeclarations.pop_back();
9711 assert(PendingFakeDefinitionData.empty() &&
9712 "faked up a class definition but never saw the real one");
9718 for (
Decl *D : PendingDefinitions) {
9719 if (
TagDecl *TD = dyn_cast<TagDecl>(D)) {
9720 if (
const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9725 if (
auto RD = dyn_cast<CXXRecordDecl>(D)) {
9726 for (
auto *R = getMostRecentExistingDecl(RD); R;
9727 R = R->getPreviousDecl()) {
9729 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9730 "declaration thinks it's the definition but it isn't");
9731 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9738 if (
auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9743 for (
auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9744 cast<ObjCInterfaceDecl>(R)->Data =
ID->Data;
9749 if (
auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9750 for (
auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9751 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9756 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9757 for (
auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9758 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9760 PendingDefinitions.clear();
9766 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9767 PBEnd = PendingBodies.end();
9768 PB != PBEnd; ++PB) {
9769 if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9779 if (
auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9780 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9785 if (!
getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9791 if (!FD->isLateTemplateParsed() &&
9792 !NonConstDefn->isLateTemplateParsed() &&
9796 FD->getODRHash() != NonConstDefn->getODRHash()) {
9797 if (!isa<CXXMethodDecl>(FD)) {
9798 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9799 }
else if (FD->getLexicalParent()->isFileContext() &&
9800 NonConstDefn->getLexicalParent()->isFileContext()) {
9804 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9815 PendingBodies.clear();
9818 for (
auto [RD, MD] : PendingAddedClassMembers) {
9819 RD->addedMember(MD);
9821 PendingAddedClassMembers.clear();
9824 for (
auto *ND : PendingMergedDefinitionsToDeduplicate)
9826 PendingMergedDefinitionsToDeduplicate.clear();
9829void ASTReader::diagnoseOdrViolations() {
9830 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9831 PendingRecordOdrMergeFailures.empty() &&
9832 PendingFunctionOdrMergeFailures.empty() &&
9833 PendingEnumOdrMergeFailures.empty() &&
9834 PendingObjCInterfaceOdrMergeFailures.empty() &&
9835 PendingObjCProtocolOdrMergeFailures.empty())
9842 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9843 PendingOdrMergeFailures.clear();
9844 for (
auto &Merge : OdrMergeFailures) {
9845 Merge.first->buildLookup();
9846 Merge.first->decls_begin();
9847 Merge.first->bases_begin();
9848 Merge.first->vbases_begin();
9849 for (
auto &RecordPair : Merge.second) {
9850 auto *RD = RecordPair.first;
9858 auto RecordOdrMergeFailures = std::move(PendingRecordOdrMergeFailures);
9859 PendingRecordOdrMergeFailures.clear();
9860 for (
auto &Merge : RecordOdrMergeFailures) {
9861 Merge.first->decls_begin();
9862 for (
auto &D : Merge.second)
9867 auto ObjCInterfaceOdrMergeFailures =
9868 std::move(PendingObjCInterfaceOdrMergeFailures);
9869 PendingObjCInterfaceOdrMergeFailures.clear();
9870 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
9871 Merge.first->decls_begin();
9872 for (
auto &InterfacePair : Merge.second)
9873 InterfacePair.first->decls_begin();
9877 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9878 PendingFunctionOdrMergeFailures.clear();
9879 for (
auto &Merge : FunctionOdrMergeFailures) {
9880 Merge.first->buildLookup();
9881 Merge.first->decls_begin();
9882 Merge.first->getBody();
9883 for (
auto &FD : Merge.second) {
9891 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9892 PendingEnumOdrMergeFailures.clear();
9893 for (
auto &Merge : EnumOdrMergeFailures) {
9894 Merge.first->decls_begin();
9895 for (
auto &
Enum : Merge.second) {
9896 Enum->decls_begin();
9901 auto ObjCProtocolOdrMergeFailures =
9902 std::move(PendingObjCProtocolOdrMergeFailures);
9903 PendingObjCProtocolOdrMergeFailures.clear();
9904 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
9905 Merge.first->decls_begin();
9906 for (
auto &ProtocolPair : Merge.second)
9907 ProtocolPair.first->decls_begin();
9916 while (!PendingOdrMergeChecks.empty()) {
9917 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9931 for (
auto *RI : D->
redecls()) {
9932 if (RI->getLexicalDeclContext() == CanonDef) {
9947 for (
auto *CanonMember : CanonDef->
decls()) {
9948 if (CanonMember->getCanonicalDecl() == DCanon) {
9957 if (
auto *ND = dyn_cast<NamedDecl>(CanonMember))
9959 Candidates.push_back(ND);
9965 if (!isa<TagDecl>(D))
9970 Deserializing RecursionGuard(
this);
9972 std::string CanonDefModule =
9974 cast<Decl>(CanonDef));
9977 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9979 if (Candidates.empty())
9980 Diag(cast<Decl>(CanonDef)->getLocation(),
9981 diag::note_module_odr_violation_no_possible_decls) << D;
9983 for (
unsigned I = 0, N = Candidates.size(); I != N; ++I)
9984 Diag(Candidates[I]->getLocation(),
9985 diag::note_module_odr_violation_possible_decl)
9989 DiagnosedOdrMergeFailures.insert(CanonDef);
9993 if (OdrMergeFailures.empty() && RecordOdrMergeFailures.empty() &&
9994 FunctionOdrMergeFailures.empty() && EnumOdrMergeFailures.empty() &&
9995 ObjCInterfaceOdrMergeFailures.empty() &&
9996 ObjCProtocolOdrMergeFailures.empty())
10003 for (
auto &Merge : OdrMergeFailures) {
10006 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10009 bool Diagnosed =
false;
10011 for (
auto &RecordPair : Merge.second) {
10012 if (DiagsEmitter.diagnoseMismatch(FirstRecord, RecordPair.first,
10013 RecordPair.second)) {
10026 Diag(Merge.first->getLocation(),
10027 diag::err_module_odr_violation_different_instantiations)
10034 for (
auto &Merge : RecordOdrMergeFailures) {
10037 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10041 bool Diagnosed =
false;
10042 for (
auto *SecondRecord : Merge.second) {
10043 if (DiagsEmitter.diagnoseMismatch(FirstRecord, SecondRecord)) {
10049 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10053 for (
auto &Merge : FunctionOdrMergeFailures) {
10055 bool Diagnosed =
false;
10056 for (
auto &SecondFunction : Merge.second) {
10057 if (DiagsEmitter.diagnoseMismatch(FirstFunction, SecondFunction)) {
10063 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10067 for (
auto &Merge : EnumOdrMergeFailures) {
10070 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10073 EnumDecl *FirstEnum = Merge.first;
10074 bool Diagnosed =
false;
10075 for (
auto &SecondEnum : Merge.second) {
10076 if (DiagsEmitter.diagnoseMismatch(FirstEnum, SecondEnum)) {
10082 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10085 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
10088 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10091 bool Diagnosed =
false;
10093 for (
auto &InterfacePair : Merge.second) {
10094 if (DiagsEmitter.diagnoseMismatch(FirstID, InterfacePair.first,
10095 InterfacePair.second)) {
10101 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10104 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
10107 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10111 bool Diagnosed =
false;
10112 for (
auto &ProtocolPair : Merge.second) {
10113 if (DiagsEmitter.diagnoseMismatch(FirstProtocol, ProtocolPair.first,
10114 ProtocolPair.second)) {
10120 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10125 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
10126 ReadTimer->startTimer();
10130 assert(NumCurrentElementsDeserializing &&
10131 "FinishedDeserializing not paired with StartedDeserializing");
10132 if (NumCurrentElementsDeserializing == 1) {
10135 finishPendingActions();
10137 --NumCurrentElementsDeserializing;
10139 if (NumCurrentElementsDeserializing == 0) {
10145 while (!PendingExceptionSpecUpdates.empty() ||
10146 !PendingDeducedTypeUpdates.empty()) {
10147 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
10148 PendingExceptionSpecUpdates.clear();
10149 for (
auto Update : ESUpdates) {
10150 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10154 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(
Update.second));
10155 for (
auto *Redecl :
Update.second->redecls())
10159 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
10160 PendingDeducedTypeUpdates.clear();
10161 for (
auto Update : DTUpdates) {
10162 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10168 auto UDTUpdates = std::move(PendingUndeducedFunctionDecls);
10169 PendingUndeducedFunctionDecls.clear();
10173 (void)UndeducedFD->getMostRecentDecl();
10177 ReadTimer->stopTimer();
10179 diagnoseOdrViolations();
10184 PassInterestingDeclsToConsumer();
10191 auto It = PendingFakeLookupResults.find(II);
10192 if (It != PendingFakeLookupResults.end()) {
10193 for (
auto *ND : It->second)
10198 It->second.clear();
10204 }
else if (SemaObj->
TUScope) {
10216 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
10217 StringRef isysroot,
10219 bool AllowASTWithCompilerErrors,
10220 bool AllowConfigurationMismatch,
bool ValidateSystemInputs,
10221 bool ValidateASTInputFilesContent,
bool UseGlobalIndex,
10222 std::unique_ptr<llvm::Timer> ReadTimer)
10226 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
10227 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
10228 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
10229 PCHContainerRdr, PP.getHeaderSearchInfo()),
10230 DummyIdResolver(PP), ReadTimer(
std::move(ReadTimer)), isysroot(isysroot),
10231 DisableValidationKind(DisableValidationKind),
10232 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
10233 AllowConfigurationMismatch(AllowConfigurationMismatch),
10234 ValidateSystemInputs(ValidateSystemInputs),
10235 ValidateASTInputFilesContent(ValidateASTInputFilesContent),
10236 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
10239 for (
const auto &Ext : Extensions) {
10240 auto BlockName = Ext->getExtensionMetadata().BlockName;
10241 auto Known = ModuleFileExtensions.find(BlockName);
10242 if (Known != ModuleFileExtensions.end()) {
10243 Diags.
Report(diag::warn_duplicate_module_file_extension)
10248 ModuleFileExtensions.insert({BlockName, Ext});
10253 if (OwnsDeserializationListener)
10254 delete DeserializationListener;
10258 return SemaObj ? SemaObj->
IdResolver : DummyIdResolver;
10262 unsigned AbbrevID) {
10265 return Cursor.readRecord(AbbrevID,
Record);
10282#define GEN_CLANG_CLAUSE_CLASS
10283#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
10284#include "llvm/Frontend/OpenMP/OMP.inc"
10298 switch (llvm::omp::Clause(
Record.readInt())) {
10299 case llvm::omp::OMPC_if:
10302 case llvm::omp::OMPC_final:
10305 case llvm::omp::OMPC_num_threads:
10308 case llvm::omp::OMPC_safelen:
10311 case llvm::omp::OMPC_simdlen:
10314 case llvm::omp::OMPC_sizes: {
10315 unsigned NumSizes =
Record.readInt();
10319 case llvm::omp::OMPC_full:
10322 case llvm::omp::OMPC_partial:
10325 case llvm::omp::OMPC_allocator:
10328 case llvm::omp::OMPC_collapse:
10331 case llvm::omp::OMPC_default:
10334 case llvm::omp::OMPC_proc_bind:
10337 case llvm::omp::OMPC_schedule:
10340 case llvm::omp::OMPC_ordered:
10343 case llvm::omp::OMPC_nowait:
10346 case llvm::omp::OMPC_untied:
10349 case llvm::omp::OMPC_mergeable:
10352 case llvm::omp::OMPC_read:
10355 case llvm::omp::OMPC_write:
10358 case llvm::omp::OMPC_update:
10361 case llvm::omp::OMPC_capture:
10364 case llvm::omp::OMPC_compare:
10367 case llvm::omp::OMPC_fail:
10370 case llvm::omp::OMPC_seq_cst:
10373 case llvm::omp::OMPC_acq_rel:
10376 case llvm::omp::OMPC_acquire:
10379 case llvm::omp::OMPC_release:
10382 case llvm::omp::OMPC_relaxed:
10385 case llvm::omp::OMPC_weak:
10388 case llvm::omp::OMPC_threads:
10391 case llvm::omp::OMPC_simd:
10394 case llvm::omp::OMPC_nogroup:
10397 case llvm::omp::OMPC_unified_address:
10400 case llvm::omp::OMPC_unified_shared_memory:
10403 case llvm::omp::OMPC_reverse_offload:
10406 case llvm::omp::OMPC_dynamic_allocators:
10409 case llvm::omp::OMPC_atomic_default_mem_order:
10412 case llvm::omp::OMPC_at:
10415 case llvm::omp::OMPC_severity:
10418 case llvm::omp::OMPC_message:
10421 case llvm::omp::OMPC_private:
10424 case llvm::omp::OMPC_firstprivate:
10427 case llvm::omp::OMPC_lastprivate:
10430 case llvm::omp::OMPC_shared:
10433 case llvm::omp::OMPC_reduction: {
10434 unsigned N =
Record.readInt();
10439 case llvm::omp::OMPC_task_reduction:
10442 case llvm::omp::OMPC_in_reduction:
10445 case llvm::omp::OMPC_linear:
10448 case llvm::omp::OMPC_aligned:
10451 case llvm::omp::OMPC_copyin:
10454 case llvm::omp::OMPC_copyprivate:
10457 case llvm::omp::OMPC_flush:
10460 case llvm::omp::OMPC_depobj:
10463 case llvm::omp::OMPC_depend: {
10464 unsigned NumVars =
Record.readInt();
10465 unsigned NumLoops =
Record.readInt();
10469 case llvm::omp::OMPC_device:
10472 case llvm::omp::OMPC_map: {
10481 case llvm::omp::OMPC_num_teams:
10484 case llvm::omp::OMPC_thread_limit:
10487 case llvm::omp::OMPC_priority:
10490 case llvm::omp::OMPC_grainsize:
10493 case llvm::omp::OMPC_num_tasks:
10496 case llvm::omp::OMPC_hint:
10499 case llvm::omp::OMPC_dist_schedule:
10502 case llvm::omp::OMPC_defaultmap:
10505 case llvm::omp::OMPC_to: {
10514 case llvm::omp::OMPC_from: {
10523 case llvm::omp::OMPC_use_device_ptr: {
10532 case llvm::omp::OMPC_use_device_addr: {
10541 case llvm::omp::OMPC_is_device_ptr: {
10550 case llvm::omp::OMPC_has_device_addr: {
10559 case llvm::omp::OMPC_allocate:
10562 case llvm::omp::OMPC_nontemporal:
10565 case llvm::omp::OMPC_inclusive:
10568 case llvm::omp::OMPC_exclusive:
10571 case llvm::omp::OMPC_order:
10574 case llvm::omp::OMPC_init:
10577 case llvm::omp::OMPC_use:
10580 case llvm::omp::OMPC_destroy:
10583 case llvm::omp::OMPC_novariants:
10586 case llvm::omp::OMPC_nocontext:
10589 case llvm::omp::OMPC_detach:
10592 case llvm::omp::OMPC_uses_allocators:
10595 case llvm::omp::OMPC_affinity:
10598 case llvm::omp::OMPC_filter:
10601 case llvm::omp::OMPC_bind:
10604 case llvm::omp::OMPC_align:
10607 case llvm::omp::OMPC_ompx_dyn_cgroup_mem:
10610 case llvm::omp::OMPC_doacross: {
10611 unsigned NumVars =
Record.readInt();
10612 unsigned NumLoops =
Record.readInt();
10616 case llvm::omp::OMPC_ompx_attribute:
10619 case llvm::omp::OMPC_ompx_bare:
10622#define OMP_CLAUSE_NO_CLASS(Enum, Str) \
10623 case llvm::omp::Enum: \
10625#include "llvm/Frontend/OpenMP/OMPKinds.def"
10629 assert(
C &&
"Unknown OMPClause type");
10632 C->setLocStart(
Record.readSourceLocation());
10633 C->setLocEnd(
Record.readSourceLocation());
10639 C->setPreInitStmt(
Record.readSubStmt(),
10645 C->setPostUpdateExpr(
Record.readSubExpr());
10648void OMPClauseReader::VisitOMPIfClause(
OMPIfClause *
C) {
10651 C->setNameModifierLoc(
Record.readSourceLocation());
10652 C->setColonLoc(
Record.readSourceLocation());
10653 C->setCondition(
Record.readSubExpr());
10654 C->setLParenLoc(
Record.readSourceLocation());
10659 C->setCondition(
Record.readSubExpr());
10660 C->setLParenLoc(
Record.readSourceLocation());
10665 C->setNumThreads(
Record.readSubExpr());
10666 C->setLParenLoc(
Record.readSourceLocation());
10670 C->setSafelen(
Record.readSubExpr());
10671 C->setLParenLoc(
Record.readSourceLocation());
10675 C->setSimdlen(
Record.readSubExpr());
10676 C->setLParenLoc(
Record.readSourceLocation());
10680 for (
Expr *&E :
C->getSizesRefs())
10681 E =
Record.readSubExpr();
10682 C->setLParenLoc(
Record.readSourceLocation());
10688 C->setFactor(
Record.readSubExpr());
10689 C->setLParenLoc(
Record.readSourceLocation());
10693 C->setAllocator(
Record.readExpr());
10694 C->setLParenLoc(
Record.readSourceLocation());
10698 C->setNumForLoops(
Record.readSubExpr());
10699 C->setLParenLoc(
Record.readSourceLocation());
10703 C->setDefaultKind(
static_cast<llvm::omp::DefaultKind
>(
Record.readInt()));
10704 C->setLParenLoc(
Record.readSourceLocation());
10705 C->setDefaultKindKwLoc(
Record.readSourceLocation());
10709 C->setProcBindKind(
static_cast<llvm::omp::ProcBindKind
>(
Record.readInt()));
10710 C->setLParenLoc(
Record.readSourceLocation());
10711 C->setProcBindKindKwLoc(
Record.readSourceLocation());
10716 C->setScheduleKind(
10718 C->setFirstScheduleModifier(
10720 C->setSecondScheduleModifier(
10722 C->setChunkSize(
Record.readSubExpr());
10723 C->setLParenLoc(
Record.readSourceLocation());
10724 C->setFirstScheduleModifierLoc(
Record.readSourceLocation());
10725 C->setSecondScheduleModifierLoc(
Record.readSourceLocation());
10726 C->setScheduleKindLoc(
Record.readSourceLocation());
10727 C->setCommaLoc(
Record.readSourceLocation());
10731 C->setNumForLoops(
Record.readSubExpr());
10732 for (
unsigned I = 0, E =
C->NumberOfLoops; I < E; ++I)
10733 C->setLoopNumIterations(I,
Record.readSubExpr());
10734 for (
unsigned I = 0, E =
C->NumberOfLoops; I < E; ++I)
10735 C->setLoopCounter(I,
Record.readSubExpr());
10736 C->setLParenLoc(
Record.readSourceLocation());
10740 C->setEventHandler(
Record.readSubExpr());
10741 C->setLParenLoc(
Record.readSourceLocation());
10750void OMPClauseReader::VisitOMPReadClause(
OMPReadClause *) {}
10755 if (
C->isExtended()) {
10756 C->setLParenLoc(
Record.readSourceLocation());
10757 C->setArgumentLoc(
Record.readSourceLocation());
10769 C->setLParenLoc(
Record.readSourceLocation());
10771 C->setFailParameterLoc(FailParameterLoc);
10773 C->setFailParameter(CKind);
10786void OMPClauseReader::VisitOMPWeakClause(
OMPWeakClause *) {}
10790void OMPClauseReader::VisitOMPSIMDClause(
OMPSIMDClause *) {}
10795 unsigned NumVars =
C->varlist_size();
10797 Vars.reserve(NumVars);
10798 for (
unsigned I = 0; I != NumVars; ++I)
10799 Vars.push_back(
Record.readSubExpr());
10800 C->setVarRefs(Vars);
10801 C->setIsTarget(
Record.readBool());
10802 C->setIsTargetSync(
Record.readBool());
10803 C->setLParenLoc(
Record.readSourceLocation());
10804 C->setVarLoc(
Record.readSourceLocation());
10808 C->setInteropVar(
Record.readSubExpr());
10809 C->setLParenLoc(
Record.readSourceLocation());
10810 C->setVarLoc(
Record.readSourceLocation());
10814 C->setInteropVar(
Record.readSubExpr());
10815 C->setLParenLoc(
Record.readSourceLocation());
10816 C->setVarLoc(
Record.readSourceLocation());
10821 C->setCondition(
Record.readSubExpr());
10822 C->setLParenLoc(
Record.readSourceLocation());
10827 C->setCondition(
Record.readSubExpr());
10828 C->setLParenLoc(
Record.readSourceLocation());
10833void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
10842void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
10844 C->setAtomicDefaultMemOrderKind(
10846 C->setLParenLoc(
Record.readSourceLocation());
10847 C->setAtomicDefaultMemOrderKindKwLoc(
Record.readSourceLocation());
10850void OMPClauseReader::VisitOMPAtClause(
OMPAtClause *
C) {
10852 C->setLParenLoc(
Record.readSourceLocation());
10853 C->setAtKindKwLoc(
Record.readSourceLocation());
10858 C->setLParenLoc(
Record.readSourceLocation());
10859 C->setSeverityKindKwLoc(
Record.readSourceLocation());
10863 C->setMessageString(
Record.readSubExpr());
10864 C->setLParenLoc(
Record.readSourceLocation());
10868 C->setLParenLoc(
Record.readSourceLocation());
10869 unsigned NumVars =
C->varlist_size();
10871 Vars.reserve(NumVars);
10872 for (
unsigned i = 0; i != NumVars; ++i)
10873 Vars.push_back(
Record.readSubExpr());
10874 C->setVarRefs(Vars);
10876 for (
unsigned i = 0; i != NumVars; ++i)
10877 Vars.push_back(
Record.readSubExpr());
10878 C->setPrivateCopies(Vars);
10883 C->setLParenLoc(
Record.readSourceLocation());
10884 unsigned NumVars =
C->varlist_size();
10886 Vars.reserve(NumVars);
10887 for (
unsigned i = 0; i != NumVars; ++i)
10888 Vars.push_back(
Record.readSubExpr());
10889 C->setVarRefs(Vars);
10891 for (
unsigned i = 0; i != NumVars; ++i)
10892 Vars.push_back(
Record.readSubExpr());
10893 C->setPrivateCopies(Vars);
10895 for (
unsigned i = 0; i != NumVars; ++i)
10896 Vars.push_back(
Record.readSubExpr());
10902 C->setLParenLoc(
Record.readSourceLocation());
10904 C->setKindLoc(
Record.readSourceLocation());
10905 C->setColonLoc(
Record.readSourceLocation());
10906 unsigned NumVars =
C->varlist_size();
10908 Vars.reserve(NumVars);
10909 for (
unsigned i = 0; i != NumVars; ++i)
10910 Vars.push_back(
Record.readSubExpr());
10911 C->setVarRefs(Vars);
10913 for (
unsigned i = 0; i != NumVars; ++i)
10914 Vars.push_back(
Record.readSubExpr());
10915 C->setPrivateCopies(Vars);
10917 for (
unsigned i = 0; i != NumVars; ++i)
10918 Vars.push_back(
Record.readSubExpr());
10919 C->setSourceExprs(Vars);
10921 for (
unsigned i = 0; i != NumVars; ++i)
10922 Vars.push_back(
Record.readSubExpr());
10923 C->setDestinationExprs(Vars);
10925 for (
unsigned i = 0; i != NumVars; ++i)
10926 Vars.push_back(
Record.readSubExpr());
10927 C->setAssignmentOps(Vars);
10931 C->setLParenLoc(
Record.readSourceLocation());
10932 unsigned NumVars =
C->varlist_size();
10934 Vars.reserve(NumVars);
10935 for (
unsigned i = 0; i != NumVars; ++i)
10936 Vars.push_back(
Record.readSubExpr());
10937 C->setVarRefs(Vars);
10942 C->setLParenLoc(
Record.readSourceLocation());
10943 C->setModifierLoc(
Record.readSourceLocation());
10944 C->setColonLoc(
Record.readSourceLocation());
10947 C->setQualifierLoc(NNSL);
10948 C->setNameInfo(DNI);
10950 unsigned NumVars =
C->varlist_size();
10952 Vars.reserve(NumVars);
10953 for (
unsigned i = 0; i != NumVars; ++i)
10954 Vars.push_back(
Record.readSubExpr());
10955 C->setVarRefs(Vars);
10957 for (
unsigned i = 0; i != NumVars; ++i)
10958 Vars.push_back(
Record.readSubExpr());
10959 C->setPrivates(Vars);
10961 for (
unsigned i = 0; i != NumVars; ++i)
10962 Vars.push_back(
Record.readSubExpr());
10963 C->setLHSExprs(Vars);
10965 for (
unsigned i = 0; i != NumVars; ++i)
10966 Vars.push_back(
Record.readSubExpr());
10967 C->setRHSExprs(Vars);
10969 for (
unsigned i = 0; i != NumVars; ++i)
10970 Vars.push_back(
Record.readSubExpr());
10971 C->setReductionOps(Vars);
10972 if (
C->getModifier() == OMPC_REDUCTION_inscan) {
10974 for (
unsigned i = 0; i != NumVars; ++i)
10975 Vars.push_back(
Record.readSubExpr());
10976 C->setInscanCopyOps(Vars);
10978 for (
unsigned i = 0; i != NumVars; ++i)
10979 Vars.push_back(
Record.readSubExpr());
10980 C->setInscanCopyArrayTemps(Vars);
10982 for (
unsigned i = 0; i != NumVars; ++i)
10983 Vars.push_back(
Record.readSubExpr());
10984 C->setInscanCopyArrayElems(Vars);
10990 C->setLParenLoc(
Record.readSourceLocation());
10991 C->setColonLoc(
Record.readSourceLocation());
10994 C->setQualifierLoc(NNSL);
10995 C->setNameInfo(DNI);
10997 unsigned NumVars =
C->varlist_size();
10999 Vars.reserve(NumVars);
11000 for (
unsigned I = 0; I != NumVars; ++I)
11001 Vars.push_back(
Record.readSubExpr());
11002 C->setVarRefs(Vars);
11004 for (
unsigned I = 0; I != NumVars; ++I)
11005 Vars.push_back(
Record.readSubExpr());
11006 C->setPrivates(Vars);
11008 for (
unsigned I = 0; I != NumVars; ++I)
11009 Vars.push_back(
Record.readSubExpr());
11010 C->setLHSExprs(Vars);
11012 for (
unsigned I = 0; I != NumVars; ++I)
11013 Vars.push_back(
Record.readSubExpr());
11014 C->setRHSExprs(Vars);
11016 for (
unsigned I = 0; I != NumVars; ++I)
11017 Vars.push_back(
Record.readSubExpr());
11018 C->setReductionOps(Vars);
11023 C->setLParenLoc(
Record.readSourceLocation());
11024 C->setColonLoc(
Record.readSourceLocation());
11027 C->setQualifierLoc(NNSL);
11028 C->setNameInfo(DNI);
11030 unsigned NumVars =
C->varlist_size();
11032 Vars.reserve(NumVars);
11033 for (
unsigned I = 0; I != NumVars; ++I)
11034 Vars.push_back(
Record.readSubExpr());
11035 C->setVarRefs(Vars);
11037 for (
unsigned I = 0; I != NumVars; ++I)
11038 Vars.push_back(
Record.readSubExpr());
11039 C->setPrivates(Vars);
11041 for (
unsigned I = 0; I != NumVars; ++I)
11042 Vars.push_back(
Record.readSubExpr());
11043 C->setLHSExprs(Vars);
11045 for (
unsigned I = 0; I != NumVars; ++I)
11046 Vars.push_back(
Record.readSubExpr());
11047 C->setRHSExprs(Vars);
11049 for (
unsigned I = 0; I != NumVars; ++I)
11050 Vars.push_back(
Record.readSubExpr());
11051 C->setReductionOps(Vars);
11053 for (
unsigned I = 0; I != NumVars; ++I)
11054 Vars.push_back(
Record.readSubExpr());
11055 C->setTaskgroupDescriptors(Vars);
11060 C->setLParenLoc(
Record.readSourceLocation());
11061 C->setColonLoc(
Record.readSourceLocation());
11063 C->setModifierLoc(
Record.readSourceLocation());
11064 unsigned NumVars =
C->varlist_size();
11066 Vars.reserve(NumVars);
11067 for (
unsigned i = 0; i != NumVars; ++i)
11068 Vars.push_back(
Record.readSubExpr());
11069 C->setVarRefs(Vars);
11071 for (
unsigned i = 0; i != NumVars; ++i)
11072 Vars.push_back(
Record.readSubExpr());
11073 C->setPrivates(Vars);
11075 for (
unsigned i = 0; i != NumVars; ++i)
11076 Vars.push_back(
Record.readSubExpr());
11079 for (
unsigned i = 0; i != NumVars; ++i)
11080 Vars.push_back(
Record.readSubExpr());
11081 C->setUpdates(Vars);
11083 for (
unsigned i = 0; i != NumVars; ++i)
11084 Vars.push_back(
Record.readSubExpr());
11085 C->setFinals(Vars);
11086 C->setStep(
Record.readSubExpr());
11087 C->setCalcStep(
Record.readSubExpr());
11089 for (
unsigned I = 0; I != NumVars + 1; ++I)
11090 Vars.push_back(
Record.readSubExpr());
11091 C->setUsedExprs(Vars);
11095 C->setLParenLoc(
Record.readSourceLocation());
11096 C->setColonLoc(
Record.readSourceLocation());
11097 unsigned NumVars =
C->varlist_size();
11099 Vars.reserve(NumVars);
11100 for (
unsigned i = 0; i != NumVars; ++i)
11101 Vars.push_back(
Record.readSubExpr());
11102 C->setVarRefs(Vars);
11103 C->setAlignment(
Record.readSubExpr());
11107 C->setLParenLoc(
Record.readSourceLocation());
11108 unsigned NumVars =
C->varlist_size();
11110 Exprs.reserve(NumVars);
11111 for (
unsigned i = 0; i != NumVars; ++i)
11112 Exprs.push_back(
Record.readSubExpr());
11113 C->setVarRefs(Exprs);
11115 for (
unsigned i = 0; i != NumVars; ++i)
11116 Exprs.push_back(
Record.readSubExpr());
11117 C->setSourceExprs(Exprs);
11119 for (
unsigned i = 0; i != NumVars; ++i)
11120 Exprs.push_back(
Record.readSubExpr());
11121 C->setDestinationExprs(Exprs);
11123 for (
unsigned i = 0; i != NumVars; ++i)
11124 Exprs.push_back(
Record.readSubExpr());
11125 C->setAssignmentOps(Exprs);
11129 C->setLParenLoc(
Record.readSourceLocation());
11130 unsigned NumVars =
C->varlist_size();
11132 Exprs.reserve(NumVars);
11133 for (
unsigned i = 0; i != NumVars; ++i)
11134 Exprs.push_back(
Record.readSubExpr());
11135 C->setVarRefs(Exprs);
11137 for (
unsigned i = 0; i != NumVars; ++i)
11138 Exprs.push_back(
Record.readSubExpr());
11139 C->setSourceExprs(Exprs);
11141 for (
unsigned i = 0; i != NumVars; ++i)
11142 Exprs.push_back(
Record.readSubExpr());
11143 C->setDestinationExprs(Exprs);
11145 for (
unsigned i = 0; i != NumVars; ++i)
11146 Exprs.push_back(
Record.readSubExpr());
11147 C->setAssignmentOps(Exprs);
11151 C->setLParenLoc(
Record.readSourceLocation());
11152 unsigned NumVars =
C->varlist_size();
11154 Vars.reserve(NumVars);
11155 for (
unsigned i = 0; i != NumVars; ++i)
11156 Vars.push_back(
Record.readSubExpr());
11157 C->setVarRefs(Vars);
11161 C->setDepobj(
Record.readSubExpr());
11162 C->setLParenLoc(
Record.readSourceLocation());
11166 C->setLParenLoc(
Record.readSourceLocation());
11167 C->setModifier(
Record.readSubExpr());
11168 C->setDependencyKind(
11170 C->setDependencyLoc(
Record.readSourceLocation());
11171 C->setColonLoc(
Record.readSourceLocation());
11172 C->setOmpAllMemoryLoc(
Record.readSourceLocation());
11173 unsigned NumVars =
C->varlist_size();
11175 Vars.reserve(NumVars);
11176 for (
unsigned I = 0; I != NumVars; ++I)
11177 Vars.push_back(
Record.readSubExpr());
11178 C->setVarRefs(Vars);
11179 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
11180 C->setLoopData(I,
Record.readSubExpr());
11186 C->setDevice(
Record.readSubExpr());
11187 C->setModifierLoc(
Record.readSourceLocation());
11188 C->setLParenLoc(
Record.readSourceLocation());
11192 C->setLParenLoc(
Record.readSourceLocation());
11193 bool HasIteratorModifier =
false;
11195 C->setMapTypeModifier(
11197 C->setMapTypeModifierLoc(I,
Record.readSourceLocation());
11198 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
11199 HasIteratorModifier =
true;
11201 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11202 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11205 C->setMapLoc(
Record.readSourceLocation());
11206 C->setColonLoc(
Record.readSourceLocation());
11207 auto NumVars =
C->varlist_size();
11208 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11209 auto TotalLists =
C->getTotalComponentListNum();
11210 auto TotalComponents =
C->getTotalComponentsNum();
11213 Vars.reserve(NumVars);
11214 for (
unsigned i = 0; i != NumVars; ++i)
11215 Vars.push_back(
Record.readExpr());
11216 C->setVarRefs(Vars);
11219 UDMappers.reserve(NumVars);
11220 for (
unsigned I = 0; I < NumVars; ++I)
11221 UDMappers.push_back(
Record.readExpr());
11222 C->setUDMapperRefs(UDMappers);
11224 if (HasIteratorModifier)
11225 C->setIteratorModifier(
Record.readExpr());
11228 Decls.reserve(UniqueDecls);
11229 for (
unsigned i = 0; i < UniqueDecls; ++i)
11231 C->setUniqueDecls(Decls);
11234 ListsPerDecl.reserve(UniqueDecls);
11235 for (
unsigned i = 0; i < UniqueDecls; ++i)
11236 ListsPerDecl.push_back(
Record.readInt());
11237 C->setDeclNumLists(ListsPerDecl);
11240 ListSizes.reserve(TotalLists);
11241 for (
unsigned i = 0; i < TotalLists; ++i)
11242 ListSizes.push_back(
Record.readInt());
11243 C->setComponentListSizes(ListSizes);
11246 Components.reserve(TotalComponents);
11247 for (
unsigned i = 0; i < TotalComponents; ++i) {
11250 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11253 C->setComponents(Components, ListSizes);
11257 C->setLParenLoc(
Record.readSourceLocation());
11258 C->setColonLoc(
Record.readSourceLocation());
11259 C->setAllocator(
Record.readSubExpr());
11260 unsigned NumVars =
C->varlist_size();
11262 Vars.reserve(NumVars);
11263 for (
unsigned i = 0; i != NumVars; ++i)
11264 Vars.push_back(
Record.readSubExpr());
11265 C->setVarRefs(Vars);
11270 C->setNumTeams(
Record.readSubExpr());
11271 C->setLParenLoc(
Record.readSourceLocation());
11276 C->setThreadLimit(
Record.readSubExpr());
11277 C->setLParenLoc(
Record.readSourceLocation());
11282 C->setPriority(
Record.readSubExpr());
11283 C->setLParenLoc(
Record.readSourceLocation());
11289 C->setGrainsize(
Record.readSubExpr());
11290 C->setModifierLoc(
Record.readSourceLocation());
11291 C->setLParenLoc(
Record.readSourceLocation());
11297 C->setNumTasks(
Record.readSubExpr());
11298 C->setModifierLoc(
Record.readSourceLocation());
11299 C->setLParenLoc(
Record.readSourceLocation());
11303 C->setHint(
Record.readSubExpr());
11304 C->setLParenLoc(
Record.readSourceLocation());
11309 C->setDistScheduleKind(
11311 C->setChunkSize(
Record.readSubExpr());
11312 C->setLParenLoc(
Record.readSourceLocation());
11313 C->setDistScheduleKindLoc(
Record.readSourceLocation());
11314 C->setCommaLoc(
Record.readSourceLocation());
11318 C->setDefaultmapKind(
11320 C->setDefaultmapModifier(
11322 C->setLParenLoc(
Record.readSourceLocation());
11323 C->setDefaultmapModifierLoc(
Record.readSourceLocation());
11324 C->setDefaultmapKindLoc(
Record.readSourceLocation());
11327void OMPClauseReader::VisitOMPToClause(
OMPToClause *
C) {
11328 C->setLParenLoc(
Record.readSourceLocation());
11330 C->setMotionModifier(
11332 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11334 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11335 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11336 C->setColonLoc(
Record.readSourceLocation());
11337 auto NumVars =
C->varlist_size();
11338 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11339 auto TotalLists =
C->getTotalComponentListNum();
11340 auto TotalComponents =
C->getTotalComponentsNum();
11343 Vars.reserve(NumVars);
11344 for (
unsigned i = 0; i != NumVars; ++i)
11345 Vars.push_back(
Record.readSubExpr());
11346 C->setVarRefs(Vars);
11349 UDMappers.reserve(NumVars);
11350 for (
unsigned I = 0; I < NumVars; ++I)
11351 UDMappers.push_back(
Record.readSubExpr());
11352 C->setUDMapperRefs(UDMappers);
11355 Decls.reserve(UniqueDecls);
11356 for (
unsigned i = 0; i < UniqueDecls; ++i)
11358 C->setUniqueDecls(Decls);
11361 ListsPerDecl.reserve(UniqueDecls);
11362 for (
unsigned i = 0; i < UniqueDecls; ++i)
11363 ListsPerDecl.push_back(
Record.readInt());
11364 C->setDeclNumLists(ListsPerDecl);
11367 ListSizes.reserve(TotalLists);
11368 for (
unsigned i = 0; i < TotalLists; ++i)
11369 ListSizes.push_back(
Record.readInt());
11370 C->setComponentListSizes(ListSizes);
11373 Components.reserve(TotalComponents);
11374 for (
unsigned i = 0; i < TotalComponents; ++i) {
11375 Expr *AssociatedExprPr =
Record.readSubExpr();
11376 bool IsNonContiguous =
Record.readBool();
11378 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11380 C->setComponents(Components, ListSizes);
11384 C->setLParenLoc(
Record.readSourceLocation());
11386 C->setMotionModifier(
11388 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11390 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11391 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11392 C->setColonLoc(
Record.readSourceLocation());
11393 auto NumVars =
C->varlist_size();
11394 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11395 auto TotalLists =
C->getTotalComponentListNum();
11396 auto TotalComponents =
C->getTotalComponentsNum();
11399 Vars.reserve(NumVars);
11400 for (
unsigned i = 0; i != NumVars; ++i)
11401 Vars.push_back(
Record.readSubExpr());
11402 C->setVarRefs(Vars);
11405 UDMappers.reserve(NumVars);
11406 for (
unsigned I = 0; I < NumVars; ++I)
11407 UDMappers.push_back(
Record.readSubExpr());
11408 C->setUDMapperRefs(UDMappers);
11411 Decls.reserve(UniqueDecls);
11412 for (
unsigned i = 0; i < UniqueDecls; ++i)
11414 C->setUniqueDecls(Decls);
11417 ListsPerDecl.reserve(UniqueDecls);
11418 for (
unsigned i = 0; i < UniqueDecls; ++i)
11419 ListsPerDecl.push_back(
Record.readInt());
11420 C->setDeclNumLists(ListsPerDecl);
11423 ListSizes.reserve(TotalLists);
11424 for (
unsigned i = 0; i < TotalLists; ++i)
11425 ListSizes.push_back(
Record.readInt());
11426 C->setComponentListSizes(ListSizes);
11429 Components.reserve(TotalComponents);
11430 for (
unsigned i = 0; i < TotalComponents; ++i) {
11431 Expr *AssociatedExprPr =
Record.readSubExpr();
11432 bool IsNonContiguous =
Record.readBool();
11434 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11436 C->setComponents(Components, ListSizes);
11440 C->setLParenLoc(
Record.readSourceLocation());
11441 auto NumVars =
C->varlist_size();
11442 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11443 auto TotalLists =
C->getTotalComponentListNum();
11444 auto TotalComponents =
C->getTotalComponentsNum();
11447 Vars.reserve(NumVars);
11448 for (
unsigned i = 0; i != NumVars; ++i)
11449 Vars.push_back(
Record.readSubExpr());
11450 C->setVarRefs(Vars);
11452 for (
unsigned i = 0; i != NumVars; ++i)
11453 Vars.push_back(
Record.readSubExpr());
11454 C->setPrivateCopies(Vars);
11456 for (
unsigned i = 0; i != NumVars; ++i)
11457 Vars.push_back(
Record.readSubExpr());
11461 Decls.reserve(UniqueDecls);
11462 for (
unsigned i = 0; i < UniqueDecls; ++i)
11464 C->setUniqueDecls(Decls);
11467 ListsPerDecl.reserve(UniqueDecls);
11468 for (
unsigned i = 0; i < UniqueDecls; ++i)
11469 ListsPerDecl.push_back(
Record.readInt());
11470 C->setDeclNumLists(ListsPerDecl);
11473 ListSizes.reserve(TotalLists);
11474 for (
unsigned i = 0; i < TotalLists; ++i)
11475 ListSizes.push_back(
Record.readInt());
11476 C->setComponentListSizes(ListSizes);
11479 Components.reserve(TotalComponents);
11480 for (
unsigned i = 0; i < TotalComponents; ++i) {
11481 auto *AssociatedExprPr =
Record.readSubExpr();
11483 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11486 C->setComponents(Components, ListSizes);
11490 C->setLParenLoc(
Record.readSourceLocation());
11491 auto NumVars =
C->varlist_size();
11492 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11493 auto TotalLists =
C->getTotalComponentListNum();
11494 auto TotalComponents =
C->getTotalComponentsNum();
11497 Vars.reserve(NumVars);
11498 for (
unsigned i = 0; i != NumVars; ++i)
11499 Vars.push_back(
Record.readSubExpr());
11500 C->setVarRefs(Vars);
11503 Decls.reserve(UniqueDecls);
11504 for (
unsigned i = 0; i < UniqueDecls; ++i)
11506 C->setUniqueDecls(Decls);
11509 ListsPerDecl.reserve(UniqueDecls);
11510 for (
unsigned i = 0; i < UniqueDecls; ++i)
11511 ListsPerDecl.push_back(
Record.readInt());
11512 C->setDeclNumLists(ListsPerDecl);
11515 ListSizes.reserve(TotalLists);
11516 for (
unsigned i = 0; i < TotalLists; ++i)
11517 ListSizes.push_back(
Record.readInt());
11518 C->setComponentListSizes(ListSizes);
11521 Components.reserve(TotalComponents);
11522 for (
unsigned i = 0; i < TotalComponents; ++i) {
11523 Expr *AssociatedExpr =
Record.readSubExpr();
11525 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11528 C->setComponents(Components, ListSizes);
11532 C->setLParenLoc(
Record.readSourceLocation());
11533 auto NumVars =
C->varlist_size();
11534 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11535 auto TotalLists =
C->getTotalComponentListNum();
11536 auto TotalComponents =
C->getTotalComponentsNum();
11539 Vars.reserve(NumVars);
11540 for (
unsigned i = 0; i != NumVars; ++i)
11541 Vars.push_back(
Record.readSubExpr());
11542 C->setVarRefs(Vars);
11546 Decls.reserve(UniqueDecls);
11547 for (
unsigned i = 0; i < UniqueDecls; ++i)
11549 C->setUniqueDecls(Decls);
11552 ListsPerDecl.reserve(UniqueDecls);
11553 for (
unsigned i = 0; i < UniqueDecls; ++i)
11554 ListsPerDecl.push_back(
Record.readInt());
11555 C->setDeclNumLists(ListsPerDecl);
11558 ListSizes.reserve(TotalLists);
11559 for (
unsigned i = 0; i < TotalLists; ++i)
11560 ListSizes.push_back(
Record.readInt());
11561 C->setComponentListSizes(ListSizes);
11564 Components.reserve(TotalComponents);
11565 for (
unsigned i = 0; i < TotalComponents; ++i) {
11566 Expr *AssociatedExpr =
Record.readSubExpr();
11568 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11571 C->setComponents(Components, ListSizes);
11575 C->setLParenLoc(
Record.readSourceLocation());
11576 auto NumVars =
C->varlist_size();
11577 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11578 auto TotalLists =
C->getTotalComponentListNum();
11579 auto TotalComponents =
C->getTotalComponentsNum();
11582 Vars.reserve(NumVars);
11583 for (
unsigned I = 0; I != NumVars; ++I)
11584 Vars.push_back(
Record.readSubExpr());
11585 C->setVarRefs(Vars);
11589 Decls.reserve(UniqueDecls);
11590 for (
unsigned I = 0; I < UniqueDecls; ++I)
11592 C->setUniqueDecls(Decls);
11595 ListsPerDecl.reserve(UniqueDecls);
11596 for (
unsigned I = 0; I < UniqueDecls; ++I)
11597 ListsPerDecl.push_back(
Record.readInt());
11598 C->setDeclNumLists(ListsPerDecl);
11601 ListSizes.reserve(TotalLists);
11602 for (
unsigned i = 0; i < TotalLists; ++i)
11603 ListSizes.push_back(
Record.readInt());
11604 C->setComponentListSizes(ListSizes);
11607 Components.reserve(TotalComponents);
11608 for (
unsigned I = 0; I < TotalComponents; ++I) {
11609 Expr *AssociatedExpr =
Record.readSubExpr();
11611 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11614 C->setComponents(Components, ListSizes);
11618 C->setLParenLoc(
Record.readSourceLocation());
11619 unsigned NumVars =
C->varlist_size();
11621 Vars.reserve(NumVars);
11622 for (
unsigned i = 0; i != NumVars; ++i)
11623 Vars.push_back(
Record.readSubExpr());
11624 C->setVarRefs(Vars);
11626 Vars.reserve(NumVars);
11627 for (
unsigned i = 0; i != NumVars; ++i)
11628 Vars.push_back(
Record.readSubExpr());
11629 C->setPrivateRefs(Vars);
11633 C->setLParenLoc(
Record.readSourceLocation());
11634 unsigned NumVars =
C->varlist_size();
11636 Vars.reserve(NumVars);
11637 for (
unsigned i = 0; i != NumVars; ++i)
11638 Vars.push_back(
Record.readSubExpr());
11639 C->setVarRefs(Vars);
11643 C->setLParenLoc(
Record.readSourceLocation());
11644 unsigned NumVars =
C->varlist_size();
11646 Vars.reserve(NumVars);
11647 for (
unsigned i = 0; i != NumVars; ++i)
11648 Vars.push_back(
Record.readSubExpr());
11649 C->setVarRefs(Vars);
11653 C->setLParenLoc(
Record.readSourceLocation());
11654 unsigned NumOfAllocators =
C->getNumberOfAllocators();
11656 Data.reserve(NumOfAllocators);
11657 for (
unsigned I = 0; I != NumOfAllocators; ++I) {
11664 C->setAllocatorsData(
Data);
11668 C->setLParenLoc(
Record.readSourceLocation());
11669 C->setModifier(
Record.readSubExpr());
11670 C->setColonLoc(
Record.readSourceLocation());
11671 unsigned NumOfLocators =
C->varlist_size();
11673 Locators.reserve(NumOfLocators);
11674 for (
unsigned I = 0; I != NumOfLocators; ++I)
11675 Locators.push_back(
Record.readSubExpr());
11676 C->setVarRefs(Locators);
11682 C->setLParenLoc(
Record.readSourceLocation());
11683 C->setKindKwLoc(
Record.readSourceLocation());
11684 C->setModifierKwLoc(
Record.readSourceLocation());
11689 C->setThreadID(
Record.readSubExpr());
11690 C->setLParenLoc(
Record.readSourceLocation());
11695 C->setLParenLoc(
Record.readSourceLocation());
11696 C->setBindKindLoc(
Record.readSourceLocation());
11700 C->setAlignment(
Record.readExpr());
11701 C->setLParenLoc(
Record.readSourceLocation());
11706 C->setSize(
Record.readSubExpr());
11707 C->setLParenLoc(
Record.readSourceLocation());
11711 C->setLParenLoc(
Record.readSourceLocation());
11712 C->setDependenceType(
11714 C->setDependenceLoc(
Record.readSourceLocation());
11715 C->setColonLoc(
Record.readSourceLocation());
11716 unsigned NumVars =
C->varlist_size();
11718 Vars.reserve(NumVars);
11719 for (
unsigned I = 0; I != NumVars; ++I)
11720 Vars.push_back(
Record.readSubExpr());
11721 C->setVarRefs(Vars);
11722 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
11723 C->setLoopData(I,
Record.readSubExpr());
11728 Record.readAttributes(Attrs);
11729 C->setAttrs(Attrs);
11730 C->setLocStart(
Record.readSourceLocation());
11731 C->setLParenLoc(
Record.readSourceLocation());
11732 C->setLocEnd(
Record.readSourceLocation());
11741 Set.Kind = readEnum<llvm::omp::TraitSet>();
11744 Selector.Kind = readEnum<llvm::omp::TraitSelector>();
11745 Selector.ScoreOrCondition =
nullptr;
11747 Selector.ScoreOrCondition = readExprRef();
11750 Property.Kind = readEnum<llvm::omp::TraitProperty>();
11759 if (Reader->ReadingKind == ASTReader::Read_Stmt) {
11764 for (
unsigned I = 0, E =
Data->getNumClauses(); I < E; ++I)
11766 Data->setClauses(Clauses);
11767 if (
Data->hasAssociatedStmt())
11769 for (
unsigned I = 0, E =
Data->getNumChildren(); I < E; ++I)
11778 switch (ClauseKind) {
11799 unsigned NumClauses =
readInt();
11801 for (
unsigned I = 0; I < NumClauses; ++I)
11855 llvm_unreachable(
"Clause serialization not yet implemented");
11857 llvm_unreachable(
"Invalid Clause Kind");
11862 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 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 bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, StringRef ExistingModuleCachePath, DiagnosticsEngine *Diags, const LangOptions &LangOpts, const PreprocessorOptions &PPOpts)
Check the header search options deserialized from the control block against the header search options...
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)
ContinuousRangeMap< unsigned, int, 2 > SLocRemap
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.
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.
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 ObjCBuiltinIdTy
RecordDecl * getCFConstantStringTagDecl() const
CanQualType UnsignedFractTy
CanQualType ObjCBuiltinClassTy
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)
CanQualType OMPArraySectionTy
virtual void MacroRead(serialization::MacroID ID, MacroInfo *MI)
A macro was read from the AST file.
virtual void IdentifierRead(serialization::IdentID ID, IdentifierInfo *II)
An identifier was deserialized from the AST file.
virtual void SelectorRead(serialization::SelectorID iD, Selector Sel)
A selector was read 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.
ExtKind hasExternalDefinitions(const Decl *D) override
IdentifierTable & getIdentifierTable()
Retrieve the identifier table associated with the preprocessor.
ModuleManager & getModuleManager()
Retrieve the module manager.
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...
serialization::DeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, serialization::GlobalDeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 > > &Exprs) override
Decl * GetDecl(serialization::GlobalDeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
serialization::GlobalDeclID getGlobalDeclID(ModuleFile &F, serialization::LocalDeclID LocalID) const
Map from a local declaration ID within a given module to a global declaration ID.
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()
void SetIdentifierInfo(unsigned ID, IdentifierInfo *II)
bool loadGlobalIndex()
Attempts to load the global index.
void ReadComments() override
Loads comments ranges.
SourceManager & getSourceManager() const
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...
bool isDeclIDFromModule(serialization::GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
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...
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.
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...
SourceLocation TranslateSourceLocation(ModuleFile &ModuleFile, SourceLocation Loc) const
Translate a source location from another module file's source location space into ours.
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.
Decl * GetLocalDecl(ModuleFile &F, serialization::LocalDeclID LocalID)
Reads a declaration with the given local ID in the given module.
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)
serialization::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.
SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, SourceLocation::UIntTy Raw, LocSeq *Seq=nullptr) const
Read a source location from raw form.
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.
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WeakIDs) override
Read the set of weak, undeclared identifiers known to the external Sema source.
void SetGloballyVisibleDecls(IdentifierInfo *II, const SmallVectorImpl< serialization::GlobalDeclID > &DeclIDs, SmallVectorImpl< Decl * > *Decls=nullptr)
Set the globally-visible declarations associated with the given identifier.
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.
SourceLocation getSourceLocationForDeclID(serialization::GlobalDeclID ID)
Returns the source location for the decl ID.
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...
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.
Decl * GetExistingDecl(serialization::GlobalDeclID ID)
Resolve a declaration ID into a declaration.
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.
ModuleFile * getLocalModuleFile(ModuleFile &M, unsigned ID)
Retrieve the module file with a given local ID within the specified ModuleFile.
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.
SmallVector< serialization::GlobalDeclID, 16 > PreloadedDeclIDs
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.
static llvm::BitVector ReadBitVector(const RecordData &Record, const StringRef Blob)
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.
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.
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID)
Retrieve the global submodule ID given a module and its local ID number.
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.
Decl * GetExternalDecl(Decl::DeclID ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
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.
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.
serialization::GlobalDeclID readDeclID()
Reads a declaration ID from the given position in this record.
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.
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
void insert(const value_type &Val)
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.
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.
DeclID getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this 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.
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)
This is the base type for all OpenACC Clauses.
static OpenACCDefaultClause * Create(const ASTContext &C, OpenACCDefaultClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
static OpenACCIfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, 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 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)
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.
llvm::DenseMap< Selector, Lists >::iterator iterator
iterator find(Selector Sel)
std::pair< ObjCMethodList, ObjCMethodList > Lists
std::pair< iterator, bool > insert(std::pair< Selector, Lists > &&Val)
Sema - This implements semantic analysis and AST building for C.
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
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.
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.
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
Wrapper class for DeclID.
Information about a module that has been loaded by the ASTReader.
const PPEntityOffset * PreprocessedEntityOffsets
serialization::IdentID BaseIdentifierID
Base identifier ID for identifiers local to this module.
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.
const UnderalignedInt64 * TypeOffsets
Offset of each type within the bitstream, indexed by the type ID, or the representation of a Type*.
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::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.
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.
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.
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.
const serialization::LocalDeclID * FileSortedDecls
Array of file-level DeclIDs sorted by file.
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).
ContinuousRangeMap< SourceLocation::UIntTy, SourceLocation::IntTy, 2 > SLocRemap
Remapping table for source locations in this module.
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.
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)
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.
IdentID 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.
PredefinedDeclIDs
Predefined declaration 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 int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
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_OMP_ARRAY_SECTION
The placeholder type for OpenMP array section.
@ 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_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_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.
@ PREDEF_DECL_OBJC_SEL_ID
The Objective-C 'SEL' type.
@ PREDEF_DECL_UNSIGNED_INT_128_ID
The unsigned 128-bit integer type.
@ PREDEF_DECL_OBJC_CLASS_ID
The Objective-C 'Class' type.
@ PREDEF_DECL_OBJC_ID_ID
The Objective-C 'id' type.
@ PREDEF_DECL_INT_128_ID
The signed 128-bit integer type.
@ PREDEF_DECL_OBJC_INSTANCETYPE_ID
The internal 'instancetype' typedef.
@ PREDEF_DECL_BUILTIN_MS_GUID_ID
The predeclared '_GUID' struct.
@ PREDEF_DECL_MAKE_INTEGER_SEQ_ID
The internal '__make_integer_seq' template.
@ PREDEF_DECL_NULL_ID
The NULL declaration.
@ PREDEF_DECL_EXTERN_C_CONTEXT_ID
The extern "C" context.
@ PREDEF_DECL_OBJC_PROTOCOL_ID
The Objective-C 'Protocol' type.
@ PREDEF_DECL_TYPE_PACK_ELEMENT_ID
The internal '__type_pack_element' template.
@ PREDEF_DECL_BUILTIN_MS_VA_LIST_ID
The internal '__builtin_ms_va_list' typedef.
@ PREDEF_DECL_BUILTIN_VA_LIST_ID
The internal '__builtin_va_list' typedef.
@ PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID
The internal '__NSConstantString' tag type.
@ PREDEF_DECL_TRANSLATION_UNIT_ID
The translation unit.
@ PREDEF_DECL_VA_LIST_TAG
The internal '__va_list_tag' struct, if any.
@ PREDEF_DECL_CF_CONSTANT_STRING_ID
The internal '__NSConstantString' typedef.
@ 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.
uint32_t IdentID
An ID number that refers to an identifier in an 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.
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.
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
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'.
@ 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.
@ Collapse
'collapse' clause, allowed on 'loop' and Combined constructs.
@ NoHost
'nohost' clause, allowed on 'routine' directives.
@ 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
'copyin' 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'.
@ 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.
@ Tile
'tile' clause, allowed on 'loop' and Combined constructs.
@ DeviceResident
'device_resident' clause, allowed on the 'declare' construct.
@ 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.
@ 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.
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
@ 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.
Source location and bit offset of a declaration.
Describes the categories of an Objective-C class.
Source range/offset of a preprocessed entity.
uint32_t BitOffset
Offset in the AST file relative to ModuleFile::MacroOffsetsBase.
SourceLocation getBegin() const
SourceLocation getEnd() const
Source range of a skipped preprocessor region.
SourceLocation getBegin() const
SourceLocation getEnd() const
uint64_t getBitOffset() const
void insert(GlobalDeclID ID)