91#include "llvm/ADT/APFloat.h"
92#include "llvm/ADT/APInt.h"
93#include "llvm/ADT/APSInt.h"
94#include "llvm/ADT/ArrayRef.h"
95#include "llvm/ADT/DenseMap.h"
96#include "llvm/ADT/FloatingPointMode.h"
97#include "llvm/ADT/FoldingSet.h"
98#include "llvm/ADT/Hashing.h"
99#include "llvm/ADT/IntrusiveRefCntPtr.h"
100#include "llvm/ADT/STLExtras.h"
101#include "llvm/ADT/ScopeExit.h"
102#include "llvm/ADT/SmallPtrSet.h"
103#include "llvm/ADT/SmallString.h"
104#include "llvm/ADT/SmallVector.h"
105#include "llvm/ADT/StringExtras.h"
106#include "llvm/ADT/StringMap.h"
107#include "llvm/ADT/StringRef.h"
108#include "llvm/ADT/iterator_range.h"
109#include "llvm/Bitstream/BitstreamReader.h"
110#include "llvm/Support/Casting.h"
111#include "llvm/Support/Compiler.h"
112#include "llvm/Support/Compression.h"
113#include "llvm/Support/DJB.h"
114#include "llvm/Support/Endian.h"
115#include "llvm/Support/Error.h"
116#include "llvm/Support/ErrorHandling.h"
117#include "llvm/Support/FileSystem.h"
118#include "llvm/Support/LEB128.h"
119#include "llvm/Support/MemoryBuffer.h"
120#include "llvm/Support/Path.h"
121#include "llvm/Support/SaveAndRestore.h"
122#include "llvm/Support/TimeProfiler.h"
123#include "llvm/Support/Timer.h"
124#include "llvm/Support/VersionTuple.h"
125#include "llvm/Support/raw_ostream.h"
126#include "llvm/TargetParser/Triple.h"
139#include <system_error>
144using namespace clang;
147using llvm::BitstreamCursor;
155 return First->ReadFullVersionInformation(FullVersion) ||
156 Second->ReadFullVersionInformation(FullVersion);
160 First->ReadModuleName(ModuleName);
161 Second->ReadModuleName(ModuleName);
165 First->ReadModuleMapFile(ModuleMapPath);
166 Second->ReadModuleMapFile(ModuleMapPath);
172 bool AllowCompatibleDifferences) {
173 return First->ReadLanguageOptions(LangOpts, Complain,
174 AllowCompatibleDifferences) ||
175 Second->ReadLanguageOptions(LangOpts, Complain,
176 AllowCompatibleDifferences);
181 bool AllowCompatibleDifferences) {
182 return First->ReadTargetOptions(TargetOpts, Complain,
183 AllowCompatibleDifferences) ||
184 Second->ReadTargetOptions(TargetOpts, Complain,
185 AllowCompatibleDifferences);
190 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
191 Second->ReadDiagnosticOptions(DiagOpts, Complain);
197 return First->ReadFileSystemOptions(FSOpts, Complain) ||
198 Second->ReadFileSystemOptions(FSOpts, Complain);
204 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
206 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
212 std::string &SuggestedPredefines) {
213 return First->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
214 SuggestedPredefines) ||
215 Second->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
216 SuggestedPredefines);
221 First->ReadCounter(M,
Value);
222 Second->ReadCounter(M,
Value);
226 return First->needsInputFileVisitation() ||
227 Second->needsInputFileVisitation();
231 return First->needsSystemInputFileVisitation() ||
232 Second->needsSystemInputFileVisitation();
237 First->visitModuleFile(
Filename, Kind);
238 Second->visitModuleFile(
Filename, Kind);
244 bool isExplicitModule) {
245 bool Continue =
false;
246 if (First->needsInputFileVisitation() &&
247 (!isSystem || First->needsSystemInputFileVisitation()))
248 Continue |= First->visitInputFile(
Filename, isSystem, isOverridden,
250 if (Second->needsInputFileVisitation() &&
251 (!isSystem || Second->needsSystemInputFileVisitation()))
252 Continue |= Second->visitInputFile(
Filename, isSystem, isOverridden,
259 First->readModuleFileExtension(Metadata);
260 Second->readModuleFileExtension(Metadata);
280 bool AllowCompatibleDifferences =
true) {
281#define LANGOPT(Name, Bits, Default, Description) \
282 if (ExistingLangOpts.Name != LangOpts.Name) { \
285 Diags->Report(diag::err_pch_langopt_mismatch) \
286 << Description << LangOpts.Name << ExistingLangOpts.Name; \
288 Diags->Report(diag::err_pch_langopt_value_mismatch) \
294#define VALUE_LANGOPT(Name, Bits, Default, Description) \
295 if (ExistingLangOpts.Name != LangOpts.Name) { \
297 Diags->Report(diag::err_pch_langopt_value_mismatch) \
302#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
303 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
305 Diags->Report(diag::err_pch_langopt_value_mismatch) \
310#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
311 if (!AllowCompatibleDifferences) \
312 LANGOPT(Name, Bits, Default, Description)
314#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
315 if (!AllowCompatibleDifferences) \
316 ENUM_LANGOPT(Name, Bits, Default, Description)
318#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
319 if (!AllowCompatibleDifferences) \
320 VALUE_LANGOPT(Name, Bits, Default, Description)
322#define BENIGN_LANGOPT(Name, Bits, Default, Description)
323#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
324#define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description)
325#include "clang/Basic/LangOptions.def"
329 Diags->
Report(diag::err_pch_langopt_value_mismatch) <<
"module features";
335 Diags->
Report(diag::err_pch_langopt_value_mismatch)
336 <<
"target Objective-C runtime";
343 Diags->
Report(diag::err_pch_langopt_value_mismatch)
344 <<
"block command names";
352 if (!AllowCompatibleDifferences) {
356 ExistingSanitizers.
clear(ModularSanitizers);
357 ImportedSanitizers.
clear(ModularSanitizers);
358 if (ExistingSanitizers.
Mask != ImportedSanitizers.
Mask) {
359 const std::string Flag =
"-fsanitize=";
361#define SANITIZER(NAME, ID) \
363 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
364 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
365 if (InExistingModule != InImportedModule) \
366 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
367 << InExistingModule << (Flag + NAME); \
369#include "clang/Basic/Sanitizers.def"
387 bool AllowCompatibleDifferences =
true) {
388#define CHECK_TARGET_OPT(Field, Name) \
389 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
391 Diags->Report(diag::err_pch_targetopt_mismatch) \
392 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
403 if (!AllowCompatibleDifferences) {
408#undef CHECK_TARGET_OPT
416 llvm::sort(ExistingFeatures);
417 llvm::sort(ReadFeatures);
423 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
424 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
425 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
426 ExistingFeatures.begin(), ExistingFeatures.end(),
427 std::back_inserter(UnmatchedReadFeatures));
431 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
435 for (StringRef Feature : UnmatchedReadFeatures)
436 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
438 for (StringRef Feature : UnmatchedExistingFeatures)
439 Diags->
Report(diag::err_pch_targetopt_feature_mismatch)
443 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
449 bool AllowCompatibleDifferences) {
452 Complain ? &Reader.Diags :
nullptr,
453 AllowCompatibleDifferences);
458 bool AllowCompatibleDifferences) {
461 Complain ? &Reader.Diags :
nullptr,
462 AllowCompatibleDifferences);
467using MacroDefinitionsMap =
468 llvm::StringMap<std::pair<StringRef,
bool >>;
469using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
484 for (
auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
493 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror=" +
512 bool SystemHeaderWarningsInModule,
521 !SystemHeaderWarningsInModule) {
523 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Wsystem-headers";
530 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Werror";
537 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-Weverything -Werror";
544 Diags.
Report(diag::err_pch_diagopt_mismatch) <<
"-pedantic-errors";
568 assert(!ModuleName.empty() &&
"diagnostic options read before module name");
572 assert(M &&
"missing module");
587 assert(ModuleMgr.
size() >= 1 &&
"what ASTFile is this then");
596 bool SystemHeaderWarningsInModule =
603 SystemHeaderWarningsInModule, Complain);
610 MacroDefinitionsMap &Macros,
612 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
613 StringRef Macro = PPOpts.
Macros[I].first;
614 bool IsUndef = PPOpts.
Macros[I].second;
616 std::pair<StringRef, StringRef> MacroPair = Macro.split(
'=');
617 StringRef MacroName = MacroPair.first;
618 StringRef MacroBody = MacroPair.second;
622 if (MacroNames && !Macros.count(MacroName))
623 MacroNames->push_back(MacroName);
625 Macros[MacroName] = std::make_pair(
"",
true);
630 if (MacroName.size() == Macro.size())
634 StringRef::size_type End = MacroBody.find_first_of(
"\n\r");
635 MacroBody = MacroBody.substr(0, End);
638 if (MacroNames && !Macros.count(MacroName))
639 MacroNames->push_back(MacroName);
640 Macros[MacroName] = std::make_pair(MacroBody,
false);
664 std::string &SuggestedPredefines,
const LangOptions &LangOpts,
668 MacroDefinitionsMap ASTFileMacros;
670 MacroDefinitionsMap ExistingMacros;
673 &ExistingMacroNames);
677 SuggestedPredefines +=
"# 1 \"<command line>\" 1\n";
679 for (
unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
681 StringRef MacroName = ExistingMacroNames[I];
682 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
685 llvm::StringMap<std::pair<StringRef,
bool >>::iterator Known =
686 ASTFileMacros.find(MacroName);
692 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
true;
700 if (Existing.second) {
701 SuggestedPredefines +=
"#undef ";
702 SuggestedPredefines += MacroName.str();
703 SuggestedPredefines +=
'\n';
705 SuggestedPredefines +=
"#define ";
706 SuggestedPredefines += MacroName.str();
707 SuggestedPredefines +=
' ';
708 SuggestedPredefines += Existing.first.str();
709 SuggestedPredefines +=
'\n';
716 if (Existing.second != Known->second.second) {
718 Diags->
Report(diag::err_pch_macro_def_undef)
719 << MacroName << Known->second.second;
726 if (Existing.second || Existing.first == Known->second.first) {
727 ASTFileMacros.erase(Known);
733 Diags->
Report(diag::err_pch_macro_def_conflict)
734 << MacroName << Known->second.first << Existing.first;
740 SuggestedPredefines +=
"# 1 \"<built-in>\" 2\n";
745 for (
const auto &MacroName : ASTFileMacros.keys()) {
747 Diags->
Report(diag::err_pch_macro_def_undef) << MacroName <<
false;
764 if (LangOpts.Modules &&
774 for (
unsigned I = 0, N = ExistingPPOpts.
Includes.size(); I != N; ++I) {
781 SuggestedPredefines +=
"#include \"";
782 SuggestedPredefines +=
File;
783 SuggestedPredefines +=
"\"\n";
793 SuggestedPredefines +=
"#include \"";
794 SuggestedPredefines +=
File;
795 SuggestedPredefines +=
"\"\n";
798 for (
unsigned I = 0, N = ExistingPPOpts.
MacroIncludes.size(); I != N; ++I) {
803 SuggestedPredefines +=
"#__include_macros \"";
804 SuggestedPredefines +=
File;
805 SuggestedPredefines +=
"\"\n##\n";
812 bool ReadMacros,
bool Complain,
813 std::string &SuggestedPredefines) {
817 PPOpts, ExistingPPOpts, ReadMacros, Complain ? &Reader.Diags :
nullptr,
823 std::string &SuggestedPredefines) {
835 StringRef SpecificModuleCachePath,
836 StringRef ExistingModuleCachePath,
840 if (LangOpts.Modules) {
841 if (SpecificModuleCachePath != ExistingModuleCachePath &&
844 Diags->
Report(diag::err_pch_modulecache_mismatch)
845 << SpecificModuleCachePath << ExistingModuleCachePath;
854 StringRef SpecificModuleCachePath,
858 Complain ? &Reader.Diags :
nullptr,
872 const char *Error =
nullptr;
874 uint64_t Val = llvm::decodeULEB128(
P, &Length,
nullptr, &Error);
876 llvm::report_fatal_error(Error);
882static std::pair<unsigned, unsigned>
885 if ((
unsigned)KeyLen != KeyLen)
886 llvm::report_fatal_error(
"key too large");
889 if ((
unsigned)DataLen != DataLen)
890 llvm::report_fatal_error(
"data too large");
892 return std::make_pair(KeyLen, DataLen);
896 bool TakeOwnership) {
897 DeserializationListener = Listener;
898 OwnsDeserializationListener = TakeOwnership;
905std::pair<unsigned, unsigned>
912 using namespace llvm::support;
916 endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
918 F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
925 Args.push_back(FirstII);
926 for (
unsigned I = 1; I != N; ++I)
927 Args.push_back(Reader.getLocalIdentifier(
928 F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)));
936 using namespace llvm::support;
940 Result.ID = Reader.getGlobalSelectorID(
941 F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
942 unsigned FullInstanceBits =
943 endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
944 unsigned FullFactoryBits =
945 endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
946 Result.InstanceBits = FullInstanceBits & 0x3;
947 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
948 Result.FactoryBits = FullFactoryBits & 0x3;
949 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
950 unsigned NumInstanceMethods = FullInstanceBits >> 3;
951 unsigned NumFactoryMethods = FullFactoryBits >> 3;
954 for (
unsigned I = 0; I != NumInstanceMethods; ++I) {
957 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)))
958 Result.Instance.push_back(Method);
962 for (
unsigned I = 0; I != NumFactoryMethods; ++I) {
965 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)))
966 Result.Factory.push_back(Method);
973 return llvm::djbHash(a);
976std::pair<unsigned, unsigned>
983 assert(n >= 2 && d[n-1] ==
'\0');
984 return StringRef((
const char*) d, n-1);
1001 bool Value = Bits & 0x1;
1007 using namespace llvm::support;
1010 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1011 return Reader.getGlobalIdentifierID(F, RawID >> 1);
1024 const unsigned char* d,
1026 using namespace llvm::support;
1029 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1030 bool IsInteresting = RawID & 0x01;
1038 II = &Reader.getIdentifierTable().getOwn(k);
1042 Reader.markIdentifierUpToDate(II);
1044 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
1045 if (!IsInteresting) {
1048 Reader.SetIdentifierInfo(ID, II);
1052 unsigned ObjCOrBuiltinID =
1053 endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
1055 endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
1056 bool CPlusPlusOperatorKeyword =
readBit(Bits);
1057 bool HasRevertedTokenIDToIdentifier =
readBit(Bits);
1058 bool Poisoned =
readBit(Bits);
1059 bool ExtensionToken =
readBit(Bits);
1060 bool HadMacroDefinition =
readBit(Bits);
1062 assert(Bits == 0 &&
"Extra bits in the identifier?");
1067 if (HasRevertedTokenIDToIdentifier && II->
getTokenID() != tok::identifier)
1072 "Incorrect extension token flag");
1073 (void)ExtensionToken;
1077 "Incorrect C++ operator keyword flag");
1078 (void)CPlusPlusOperatorKeyword;
1082 if (HadMacroDefinition) {
1083 uint32_t MacroDirectivesOffset =
1084 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1087 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1090 Reader.SetIdentifierInfo(ID, II);
1096 for (; DataLen > 0; DataLen -= 4)
1097 DeclIDs.push_back(Reader.getGlobalDeclID(
1099 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)));
1100 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1107 : Kind(Name.getNameKind()) {
1110 Data = (uint64_t)Name.getAsIdentifierInfo();
1115 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1118 Data = Name.getCXXOverloadedOperator();
1121 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1124 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1125 ->getDeclName().getAsIdentifierInfo();
1137 llvm::FoldingSetNodeID ID;
1138 ID.AddInteger(Kind);
1161 return ID.ComputeHash();
1165ASTDeclContextNameLookupTrait::ReadFileRef(
const unsigned char *&d) {
1166 using namespace llvm::support;
1168 uint32_t ModuleFileID =
1169 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1170 return Reader.getLocalModuleFile(F, ModuleFileID);
1173std::pair<unsigned, unsigned>
1174ASTDeclContextNameLookupTrait::ReadKeyDataLength(
const unsigned char *&d) {
1179ASTDeclContextNameLookupTrait::ReadKey(
const unsigned char *d,
unsigned) {
1180 using namespace llvm::support;
1188 Data = (uint64_t)Reader.getLocalIdentifier(
1189 F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
1198 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
1217 const unsigned char *d,
1220 using namespace llvm::support;
1222 for (
unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1224 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
1225 Val.
insert(Reader.getGlobalDeclID(F, LocalID));
1229bool ASTReader::ReadLexicalDeclContextStorage(
ModuleFile &M,
1230 BitstreamCursor &Cursor,
1233 assert(Offset != 0);
1236 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1237 Error(std::move(Err));
1245 Error(MaybeCode.takeError());
1248 unsigned Code = MaybeCode.get();
1251 if (!MaybeRecCode) {
1252 Error(MaybeRecCode.takeError());
1255 unsigned RecCode = MaybeRecCode.get();
1257 Error(
"Expected lexical block");
1261 assert(!isa<TranslationUnitDecl>(DC) &&
1262 "expected a TU_UPDATE_LEXICAL record for TU");
1267 auto &Lex = LexicalDecls[DC];
1269 Lex = std::make_pair(
1271 reinterpret_cast<const llvm::support::unaligned_uint32_t *
>(
1279bool ASTReader::ReadVisibleDeclContextStorage(
ModuleFile &M,
1280 BitstreamCursor &Cursor,
1283 assert(Offset != 0);
1286 if (llvm::Error Err =
Cursor.JumpToBit(Offset)) {
1287 Error(std::move(Err));
1295 Error(MaybeCode.takeError());
1298 unsigned Code = MaybeCode.get();
1301 if (!MaybeRecCode) {
1302 Error(MaybeRecCode.takeError());
1305 unsigned RecCode = MaybeRecCode.get();
1307 Error(
"Expected visible lookup table block");
1313 auto *
Data = (
const unsigned char*)Blob.data();
1314 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&M,
Data});
1318void ASTReader::Error(StringRef Msg)
const {
1319 Error(diag::err_fe_pch_malformed, Msg);
1320 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1321 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1322 Diag(diag::note_module_cache_path)
1323 << PP.getHeaderSearchInfo().getModuleCachePath();
1327void ASTReader::Error(
unsigned DiagID, StringRef Arg1, StringRef Arg2,
1328 StringRef Arg3)
const {
1329 if (Diags.isDiagnosticInFlight())
1330 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1332 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1335void ASTReader::Error(llvm::Error &&Err)
const {
1336 llvm::Error RemainingErr =
1343 assert(NumArgs <= 3 &&
"Can only have up to 3 arguments");
1344 StringRef Arg1, Arg2, Arg3;
1347 Arg3 =
Diag.getStringArg(2);
1350 Arg2 =
Diag.getStringArg(1);
1353 Arg1 =
Diag.getStringArg(0);
1355 Error(
Diag.getDiagID(), Arg1, Arg2, Arg3);
1371 std::map<int, int> FileIDs;
1373 for (
unsigned I = 0;
Record[Idx]; ++I) {
1381 std::vector<LineEntry> Entries;
1382 while (Idx <
Record.size()) {
1386 unsigned NumEntries =
Record[Idx++];
1387 assert(NumEntries &&
"no line entries for file ID");
1389 Entries.reserve(NumEntries);
1390 for (
unsigned I = 0; I != NumEntries; ++I) {
1391 unsigned FileOffset =
Record[Idx++];
1392 unsigned LineNo =
Record[Idx++];
1393 int FilenameID = FileIDs[
Record[Idx++]];
1396 unsigned IncludeOffset =
Record[Idx++];
1398 FileKind, IncludeOffset));
1405llvm::Error ASTReader::ReadSourceManagerBlock(
ModuleFile &F) {
1406 using namespace SrcMgr;
1414 SLocEntryCursor = F.
Stream;
1417 if (llvm::Error Err = F.
Stream.SkipBlock())
1428 SLocEntryCursor.advanceSkippingSubblocks();
1430 return MaybeE.takeError();
1431 llvm::BitstreamEntry E = MaybeE.get();
1434 case llvm::BitstreamEntry::SubBlock:
1435 case llvm::BitstreamEntry::Error:
1436 return llvm::createStringError(std::errc::illegal_byte_sequence,
1437 "malformed block record in AST file");
1438 case llvm::BitstreamEntry::EndBlock:
1439 return llvm::Error::success();
1440 case llvm::BitstreamEntry::Record:
1449 SLocEntryCursor.readRecord(E.ID,
Record, &Blob);
1451 return MaybeRecord.takeError();
1452 switch (MaybeRecord.get()) {
1460 return llvm::Error::success();
1471 return std::move(Err);
1475 return MaybeEntry.takeError();
1477 llvm::BitstreamEntry Entry = MaybeEntry.get();
1478 if (Entry.Kind != llvm::BitstreamEntry::Record)
1479 return llvm::createStringError(
1480 std::errc::illegal_byte_sequence,
1481 "incorrectly-formatted source location entry in AST file");
1487 return MaybeSLOC.takeError();
1489 switch (MaybeSLOC.get()) {
1491 return llvm::createStringError(
1492 std::errc::illegal_byte_sequence,
1493 "incorrectly-formatted source location entry in AST file");
1503 GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - SLocOffset - 1);
1504 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
1505 "Corrupted global sloc offset map");
1510 auto It = llvm::upper_bound(
1513 int ID = F->SLocEntryBaseID + LocalIndex;
1514 std::size_t Index = -ID - 2;
1515 if (!SourceMgr.SLocEntryOffsetLoaded[Index]) {
1516 assert(!SourceMgr.SLocEntryLoaded[Index]);
1517 auto MaybeEntryOffset = readSLocOffset(F, LocalIndex);
1518 if (!MaybeEntryOffset) {
1519 Error(MaybeEntryOffset.takeError());
1523 SourceMgr.LoadedSLocEntryTable[Index] =
1524 SrcMgr::SLocEntry::getOffsetOnly(*MaybeEntryOffset);
1525 SourceMgr.SLocEntryOffsetLoaded[Index] = true;
1527 return Offset < SourceMgr.LoadedSLocEntryTable[Index].getOffset();
1542 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1543 Error(
"source location entry ID out-of-range for AST file");
1549 auto ReadBuffer = [
this](
1550 BitstreamCursor &SLocEntryCursor,
1551 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1556 Error(MaybeCode.takeError());
1559 unsigned Code = MaybeCode.get();
1562 SLocEntryCursor.readRecord(Code,
Record, &Blob);
1563 if (!MaybeRecCode) {
1564 Error(MaybeRecCode.takeError());
1567 unsigned RecCode = MaybeRecCode.get();
1572 const llvm::compression::Format F =
1573 Blob.size() > 0 && Blob.data()[0] == 0x78
1574 ? llvm::compression::Format::Zlib
1575 : llvm::compression::Format::Zstd;
1576 if (
const char *Reason = llvm::compression::getReasonIfUnsupported(F)) {
1581 if (llvm::Error E = llvm::compression::decompress(
1582 F, llvm::arrayRefFromStringRef(Blob), Decompressed,
Record[0])) {
1583 Error(
"could not decompress embedded file contents: " +
1584 llvm::toString(std::move(E)));
1587 return llvm::MemoryBuffer::getMemBufferCopy(
1588 llvm::toStringRef(Decompressed), Name);
1590 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name,
true);
1592 Error(
"AST record has invalid code");
1597 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1601 Error(std::move(Err));
1608 ++NumSLocEntriesRead;
1611 Error(MaybeEntry.takeError());
1614 llvm::BitstreamEntry Entry = MaybeEntry.get();
1616 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1617 Error(
"incorrectly-formatted source location entry in AST file");
1624 SLocEntryCursor.readRecord(Entry.ID,
Record, &Blob);
1626 Error(MaybeSLOC.takeError());
1629 switch (MaybeSLOC.get()) {
1631 Error(
"incorrectly-formatted source location entry in AST file");
1637 unsigned InputID =
Record[4];
1638 InputFile IF = getInputFile(*F, InputID);
1651 IncludeLoc = getImportLocation(F);
1655 FileID FID = SourceMgr.createFileID(*
File, IncludeLoc, FileCharacter, ID,
1659 FileInfo.NumCreatedFIDs =
Record[5];
1663 unsigned NumFileDecls =
Record[7];
1664 if (NumFileDecls && ContextObj) {
1666 assert(F->
FileSortedDecls &&
"FILE_SORTED_DECLS not encountered yet ?");
1672 SourceMgr.getOrCreateContentCache(*
File, isSystem(FileCharacter));
1676 auto Buffer = ReadBuffer(SLocEntryCursor,
File->getName());
1679 SourceMgr.overrideFileContents(*
File, std::move(Buffer));
1686 const char *Name = Blob.data();
1687 unsigned Offset =
Record[0];
1692 IncludeLoc = getImportLocation(F);
1695 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1698 FileID FID = SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1699 BaseOffset + Offset, IncludeLoc);
1713 SourceMgr.createExpansionLoc(SpellingLoc, ExpansionBegin, ExpansionEnd,
1727 if (
unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1728 Error(
"source location entry ID out-of-range for AST file");
1733 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1751 assert(SourceMgr.getMainFileID().isValid() &&
"missing main file");
1752 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1762 uint64_t *StartOfBlockOffset) {
1763 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID))
1766 if (StartOfBlockOffset)
1767 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1770 uint64_t Offset = Cursor.GetCurrentBitNo();
1773 return MaybeCode.takeError();
1774 unsigned Code = MaybeCode.get();
1777 if (Code != llvm::bitc::DEFINE_ABBREV) {
1778 if (llvm::Error Err = Cursor.JumpToBit(Offset))
1780 return llvm::Error::success();
1782 if (llvm::Error Err = Cursor.ReadAbbrevRecord())
1798 case tok::annot_pragma_loop_hint: {
1801 Info->Option = ReadToken(M,
Record, Idx);
1802 unsigned NumTokens =
Record[Idx++];
1804 Toks.reserve(NumTokens);
1805 for (
unsigned I = 0; I < NumTokens; ++I)
1806 Toks.push_back(ReadToken(M,
Record, Idx));
1807 Info->Toks =
llvm::ArrayRef(Toks).copy(PP.getPreprocessorAllocator());
1811 case tok::annot_pragma_pack: {
1814 auto SlotLabel = ReadString(
Record, Idx);
1816 llvm::StringRef(SlotLabel).copy(PP.getPreprocessorAllocator());
1817 Info->Alignment = ReadToken(M,
Record, Idx);
1822 case tok::annot_pragma_openmp:
1823 case tok::annot_pragma_openmp_end:
1824 case tok::annot_pragma_unused:
1825 case tok::annot_pragma_openacc:
1826 case tok::annot_pragma_openacc_end:
1829 llvm_unreachable(
"missing deserialization code for annotation token");
1846 if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1848 consumeError(std::move(Err));
1860 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1862 Stream.advanceSkippingSubblocks(Flags);
1864 Error(MaybeEntry.takeError());
1867 llvm::BitstreamEntry Entry = MaybeEntry.get();
1869 switch (Entry.Kind) {
1870 case llvm::BitstreamEntry::SubBlock:
1871 case llvm::BitstreamEntry::Error:
1872 Error(
"malformed block record in AST file");
1874 case llvm::BitstreamEntry::EndBlock:
1876 case llvm::BitstreamEntry::Record:
1887 Error(MaybeRecType.takeError());
1903 unsigned NextIndex = 1;
1905 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1910 PP.getPreprocessorAllocator());
1913 bool isC99VarArgs =
Record[NextIndex++];
1914 bool isGNUVarArgs =
Record[NextIndex++];
1915 bool hasCommaPasting =
Record[NextIndex++];
1916 MacroParams.clear();
1917 unsigned NumArgs =
Record[NextIndex++];
1918 for (
unsigned i = 0; i != NumArgs; ++i)
1919 MacroParams.push_back(getLocalIdentifier(F,
Record[NextIndex++]));
1933 if (NextIndex + 1 ==
Record.size() && PP.getPreprocessingRecord() &&
1937 GlobalID = getGlobalPreprocessedEntityID(F,
Record[NextIndex]);
1939 PreprocessingRecord::PPEntityID PPID =
1940 PPRec.getPPEntityID(GlobalID - 1,
true);
1942 PPRec.getPreprocessedEntity(PPID));
1944 PPRec.RegisterMacroDefinition(Macro, PPDef);
1955 if (MacroTokens.empty()) {
1956 Error(
"unexpected number of macro tokens for a macro in AST file");
1961 MacroTokens[0] = ReadToken(F,
Record, Idx);
1962 MacroTokens = MacroTokens.drop_front();
1971 unsigned LocalID)
const {
1973 ReadModuleOffsetMap(M);
1978 &&
"Invalid index into preprocessed entity index remap");
1980 return LocalID + I->second;
1983const FileEntry *HeaderFileInfoTrait::getFile(
const internal_key_type &Key) {
1985 if (!Key.Imported) {
1991 std::string Resolved = std::string(Key.Filename);
1992 Reader.ResolveImportedPath(M, Resolved);
1999 return llvm::hash_combine(ikey.
Size, ikey.
ModTime);
2020 return FEA && FEA == FEB;
2023std::pair<unsigned, unsigned>
2024HeaderFileInfoTrait::ReadKeyDataLength(
const unsigned char*& d) {
2029HeaderFileInfoTrait::ReadKey(
const unsigned char *d,
unsigned) {
2030 using namespace llvm::support;
2034 off_t(endian::readNext<uint64_t, llvm::endianness::little, unaligned>(d));
2036 endian::readNext<uint64_t, llvm::endianness::little, unaligned>(d));
2045 using namespace llvm::support;
2047 const unsigned char *End = d + DataLen;
2049 unsigned Flags = *d++;
2051 bool Included = (Flags >> 6) & 0x01;
2056 Reader.getPreprocessor().getIncludedFiles().insert(FE);
2059 HFI.
isImport |= (Flags >> 5) & 0x01;
2061 HFI.
DirInfo = (Flags >> 1) & 0x07;
2064 M, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
2065 if (
unsigned FrameworkOffset =
2066 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)) {
2069 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
2070 HFI.
Framework = HS->getUniqueFrameworkName(FrameworkName);
2073 assert((End - d) % 4 == 0 &&
2074 "Wrong data length in HeaderFileInfo deserialization");
2076 uint32_t LocalSMID =
2077 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
2083 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
2084 Module *Mod = Reader.getSubmodule(GlobalSMID);
2087 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
2091 Reader.ResolveImportedPath(M,
Filename);
2095 ModMap.
addHeader(Mod, H, HeaderRole,
true);
2107 uint32_t MacroDirectivesOffset) {
2108 assert(NumCurrentElementsDeserializing > 0 &&
"Missing deserialization guard");
2109 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
2116 for (
ModuleFile &I : llvm::reverse(ModuleMgr)) {
2117 BitstreamCursor &MacroCursor = I.MacroCursor;
2120 if (MacroCursor.getBitcodeBytes().empty())
2123 BitstreamCursor Cursor = MacroCursor;
2124 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
2125 Error(std::move(Err));
2133 Error(MaybeE.takeError());
2136 llvm::BitstreamEntry E = MaybeE.get();
2139 case llvm::BitstreamEntry::SubBlock:
2140 case llvm::BitstreamEntry::Error:
2141 Error(
"malformed block record in AST file");
2143 case llvm::BitstreamEntry::EndBlock:
2146 case llvm::BitstreamEntry::Record: {
2150 Error(MaybeRecord.takeError());
2153 switch (MaybeRecord.get()) {
2161 updateOutOfDateIdentifier(*II);
2180 class IdentifierLookupVisitor {
2183 unsigned PriorGeneration;
2184 unsigned &NumIdentifierLookups;
2185 unsigned &NumIdentifierLookupHits;
2189 IdentifierLookupVisitor(StringRef Name,
unsigned PriorGeneration,
2190 unsigned &NumIdentifierLookups,
2191 unsigned &NumIdentifierLookupHits)
2193 PriorGeneration(PriorGeneration),
2194 NumIdentifierLookups(NumIdentifierLookups),
2195 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2209 ++NumIdentifierLookups;
2210 ASTIdentifierLookupTable::iterator Pos =
2211 IdTable->find_hashed(Name, NameHash, &Trait);
2212 if (Pos == IdTable->end())
2218 ++NumIdentifierLookupHits;
2234 unsigned PriorGeneration = 0;
2235 if (getContext().getLangOpts().Modules)
2236 PriorGeneration = IdentifierGeneration[&II];
2242 if (!loadGlobalIndex()) {
2243 if (GlobalIndex->lookupIdentifier(II.
getName(), Hits)) {
2248 IdentifierLookupVisitor Visitor(II.
getName(), PriorGeneration,
2249 NumIdentifierLookups,
2250 NumIdentifierLookupHits);
2251 ModuleMgr.visit(Visitor, HitsPtr);
2252 markIdentifierUpToDate(&II);
2262 if (getContext().getLangOpts().Modules)
2263 IdentifierGeneration[II] = getGeneration();
2267 const PendingMacroInfo &PMInfo) {
2272 if (llvm::Error Err =
2274 Error(std::move(Err));
2278 struct ModuleMacroRecord {
2291 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2293 Error(MaybeEntry.takeError());
2296 llvm::BitstreamEntry Entry = MaybeEntry.get();
2298 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2299 Error(
"malformed block record in AST file");
2306 Error(MaybePP.takeError());
2314 ModuleMacros.push_back(ModuleMacroRecord());
2315 auto &Info = ModuleMacros.back();
2316 Info.SubModID = getGlobalSubmoduleID(M,
Record[0]);
2317 Info.MI = getMacro(getGlobalMacroID(M,
Record[1]));
2318 for (
int I = 2, N =
Record.size(); I != N; ++I)
2319 Info.Overrides.push_back(getGlobalSubmoduleID(M,
Record[I]));
2324 Error(
"malformed block record in AST file");
2335 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2337 for (
auto &MMR : ModuleMacros) {
2339 for (
unsigned ModID : MMR.Overrides) {
2340 Module *Mod = getSubmodule(ModID);
2341 auto *Macro = PP.getModuleMacro(Mod, II);
2342 assert(Macro &&
"missing definition for overridden macro");
2343 Overrides.push_back(Macro);
2346 bool Inserted =
false;
2347 Module *Owner = getSubmodule(MMR.SubModID);
2348 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2359 unsigned Idx = 0, N =
Record.size();
2367 MD = PP.AllocateDefMacroDirective(MI, Loc);
2371 MD = PP.AllocateUndefMacroDirective(Loc);
2374 bool isPublic =
Record[Idx++];
2375 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2387 PP.setLoadedMacroDirective(II, Earliest, Latest);
2390bool ASTReader::shouldDisableValidationForFile(
2428 consumeError(std::move(Err));
2434 consumeError(MaybeCode.takeError());
2436 unsigned Code = MaybeCode.get();
2442 "invalid record type for input file");
2445 consumeError(Maybe.takeError());
2448 assert(
Record[0] == ID &&
"Bogus stored ID or offset");
2457 uint16_t AsRequestedLength =
Record[7];
2459 std::string NameAsRequested = Blob.substr(0, AsRequestedLength).str();
2460 std::string Name = Blob.substr(AsRequestedLength).str();
2462 ResolveImportedPath(F, NameAsRequested);
2463 ResolveImportedPath(F, Name);
2466 Name = NameAsRequested;
2468 return std::make_pair(std::move(NameAsRequested), std::move(Name));
2473 consumeError(MaybeEntry.takeError());
2474 llvm::BitstreamEntry Entry = MaybeEntry.get();
2475 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2476 "expected record type for input file hash");
2481 "invalid record type for input file hash");
2484 consumeError(Maybe.takeError());
2513 consumeError(std::move(Err));
2528 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2541 if ((Overridden || Transient || SkipChecks) && !
File)
2546 std::string ErrorStr =
"could not find file '";
2548 ErrorStr +=
"' referenced by AST file '";
2564 if ((!Overridden && !Transient) && !SkipChecks &&
2565 SM.isFileOverridden(*
File)) {
2579 enum ModificationKind {
2585 std::optional<int64_t> Old = std::nullopt;
2586 std::optional<int64_t> New = std::nullopt;
2588 auto HasInputContentChanged = [&](Change OriginalChange) {
2589 assert(ValidateASTInputFilesContent &&
2590 "We should only check the content of the inputs with "
2591 "ValidateASTInputFilesContent enabled.");
2593 if (StoredContentHash ==
static_cast<uint64_t>(llvm::hash_code(-1)))
2594 return OriginalChange;
2597 if (!MemBuffOrError) {
2599 return OriginalChange;
2600 std::string ErrorStr =
"could not get buffer for file '";
2601 ErrorStr +=
File->getName();
2604 return OriginalChange;
2608 auto ContentHash =
hash_value(MemBuffOrError.get()->getBuffer());
2609 if (StoredContentHash ==
static_cast<uint64_t>(ContentHash))
2610 return Change{Change::None};
2612 return Change{Change::Content};
2614 auto HasInputFileChanged = [&]() {
2615 if (StoredSize !=
File->getSize())
2616 return Change{Change::Size, StoredSize,
File->getSize()};
2617 if (!shouldDisableValidationForFile(F) && StoredTime &&
2618 StoredTime !=
File->getModificationTime()) {
2619 Change MTimeChange = {Change::ModTime, StoredTime,
2620 File->getModificationTime()};
2624 if (ValidateASTInputFilesContent)
2625 return HasInputContentChanged(MTimeChange);
2629 return Change{Change::None};
2632 bool IsOutOfDate =
false;
2633 auto FileChange = SkipChecks ? Change{Change::None} : HasInputFileChanged();
2639 FileChange = HasInputContentChanged(FileChange);
2642 if (!Overridden && FileChange.Kind != Change::None) {
2643 if (Complain && !Diags.isDiagnosticInFlight()) {
2646 while (!ImportStack.back()->ImportedBy.empty())
2647 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2650 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2651 Diag(diag::err_fe_ast_file_modified)
2653 << TopLevelPCHName << FileChange.Kind
2654 << (FileChange.Old && FileChange.New)
2655 << llvm::itostr(FileChange.Old.value_or(0))
2656 << llvm::itostr(FileChange.New.value_or(0));
2659 if (ImportStack.size() > 1) {
2660 Diag(diag::note_pch_required_by)
2661 <<
Filename << ImportStack[0]->FileName;
2662 for (
unsigned I = 1; I < ImportStack.size(); ++I)
2663 Diag(diag::note_pch_required_by)
2664 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2667 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2697 llvm::sys::path::append(Buffer, Prefix,
Filename);
2698 Filename.assign(Buffer.begin(), Buffer.end());
2713 llvm_unreachable(
"unknown ASTReadResult");
2717 BitstreamCursor &Stream,
unsigned ClientLoadCapabilities,
2719 std::string &SuggestedPredefines) {
2722 consumeError(std::move(Err));
2733 consumeError(MaybeEntry.takeError());
2736 llvm::BitstreamEntry Entry = MaybeEntry.get();
2738 switch (Entry.Kind) {
2739 case llvm::BitstreamEntry::Error:
2740 case llvm::BitstreamEntry::SubBlock:
2743 case llvm::BitstreamEntry::EndBlock:
2746 case llvm::BitstreamEntry::Record:
2754 if (!MaybeRecordType) {
2756 consumeError(MaybeRecordType.takeError());
2761 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2762 if (ParseLanguageOptions(
Record, Complain, Listener,
2763 AllowCompatibleConfigurationMismatch))
2764 Result = ConfigurationMismatch;
2769 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2770 if (ParseTargetOptions(
Record, Complain, Listener,
2771 AllowCompatibleConfigurationMismatch))
2772 Result = ConfigurationMismatch;
2777 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2778 if (!AllowCompatibleConfigurationMismatch &&
2779 ParseFileSystemOptions(
Record, Complain, Listener))
2780 Result = ConfigurationMismatch;
2785 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2786 if (!AllowCompatibleConfigurationMismatch &&
2787 ParseHeaderSearchOptions(
Record, Complain, Listener))
2788 Result = ConfigurationMismatch;
2793 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2794 if (!AllowCompatibleConfigurationMismatch &&
2795 ParsePreprocessorOptions(
Record, Complain, Listener,
2796 SuggestedPredefines))
2797 Result = ConfigurationMismatch;
2807 unsigned ClientLoadCapabilities) {
2808 BitstreamCursor &Stream = F.
Stream;
2811 Error(std::move(Err));
2821 bool HasReadUnhashedControlBlock =
false;
2822 auto readUnhashedControlBlockOnce = [&]() {
2823 if (!HasReadUnhashedControlBlock) {
2824 HasReadUnhashedControlBlock =
true;
2825 if (ASTReadResult
Result =
2826 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2832 bool DisableValidation = shouldDisableValidationForFile(F);
2836 unsigned NumInputs = 0;
2837 unsigned NumUserInputs = 0;
2838 StringRef BaseDirectoryAsWritten;
2842 Error(MaybeEntry.takeError());
2845 llvm::BitstreamEntry Entry = MaybeEntry.get();
2847 switch (Entry.Kind) {
2848 case llvm::BitstreamEntry::Error:
2849 Error(
"malformed block record in AST file");
2851 case llvm::BitstreamEntry::EndBlock: {
2854 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
2859 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2866 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2872 unsigned N = ValidateSystemInputs ? NumInputs : NumUserInputs;
2878 for (
unsigned I = 0; I < N; ++I) {
2879 InputFile IF = getInputFile(F, I+1, Complain);
2891 for (
unsigned I = 0; I < N; ++I) {
2892 bool IsSystem = I >= NumUserInputs;
2903 case llvm::BitstreamEntry::SubBlock:
2907 if (llvm::Error Err = Stream.SkipBlock()) {
2908 Error(std::move(Err));
2912 Error(
"malformed block record in AST file");
2922 if (Listener && !ImportedBy) {
2928 bool AllowCompatibleConfigurationMismatch =
2932 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2933 AllowCompatibleConfigurationMismatch, *Listener,
2934 SuggestedPredefines);
2936 Error(
"malformed block record in AST file");
2940 if (DisableValidation ||
2941 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
2949 }
else if (llvm::Error Err = Stream.SkipBlock()) {
2950 Error(std::move(Err));
2956 if (llvm::Error Err = Stream.SkipBlock()) {
2957 Error(std::move(Err));
2963 case llvm::BitstreamEntry::Record:
2972 Stream.readRecord(Entry.ID,
Record, &Blob);
2973 if (!MaybeRecordType) {
2974 Error(MaybeRecordType.takeError());
2980 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2982 : diag::err_pch_version_too_new);
2986 bool hasErrors =
Record[7];
2987 if (hasErrors && !DisableValidation) {
2990 if ((ClientLoadCapabilities & ARR_TreatModuleWithErrorsAsOutOfDate) &&
2991 canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
2994 if (!AllowASTWithCompilerErrors) {
2995 Diag(diag::err_pch_with_compiler_errors);
3000 Diags.ErrorOccurred =
true;
3001 Diags.UncompilableErrorOccurred =
true;
3002 Diags.UnrecoverableErrorOccurred =
true;
3015 StringRef ASTBranch = Blob;
3016 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
3017 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3018 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
3028 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3032 unsigned Idx = 0, N =
Record.size();
3037 bool IsImportingStdCXXModule =
Record[Idx++];
3042 ReadUntranslatedSourceLocation(
Record[Idx++]);
3043 off_t StoredSize = !IsImportingStdCXXModule ? (off_t)
Record[Idx++] : 0;
3044 time_t StoredModTime =
3045 !IsImportingStdCXXModule ? (time_t)
Record[Idx++] : 0;
3048 if (!IsImportingStdCXXModule) {
3049 auto FirstSignatureByte =
Record.begin() + Idx;
3055 std::string ImportedName = ReadString(
Record, Idx);
3056 std::string ImportedFile;
3065 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
3066 ImportedName, !IsImportingStdCXXModule);
3070 if (!IsImportingStdCXXModule) {
3071 if (ImportedFile.empty()) {
3074 ImportedFile = ReadPath(BaseDirectoryAsWritten,
Record, Idx);
3077 }
else if (ImportedFile.empty()) {
3078 Diag(clang::diag::err_failed_to_find_module_file) << ImportedName;
3084 unsigned Capabilities = ClientLoadCapabilities;
3085 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3086 Capabilities &= ~ARR_Missing;
3089 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
3090 Loaded, StoredSize, StoredModTime,
3091 StoredSignature, Capabilities);
3094 bool recompilingFinalized =
3095 Result == OutOfDate && (Capabilities & ARR_OutOfDate) &&
3096 getModuleManager().getModuleCache().isPCMFinal(F.
FileName);
3098 Diag(diag::note_module_file_imported_by)
3100 if (recompilingFinalized)
3101 Diag(diag::note_module_file_conflict);
3104 case Failure:
return Failure;
3107 case OutOfDate:
return OutOfDate;
3109 case ConfigurationMismatch:
return ConfigurationMismatch;
3110 case HadErrors:
return HadErrors;
3130 Diag(diag::remark_module_import)
3132 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
3138 if (ASTReadResult
Result = readUnhashedControlBlockOnce())
3146 BaseDirectoryAsWritten = Blob;
3148 "MODULE_DIRECTORY found before MODULE_NAME");
3150 if (!PP.getPreprocessorOpts().ModulesCheckRelocated)
3154 Module *M = PP.getHeaderSearchInfo().lookupModule(
3161 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
3164 auto BuildDir = PP.getFileManager().getOptionalDirectoryRef(Blob);
3165 if (!BuildDir || *BuildDir != M->
Directory) {
3166 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
3167 Diag(diag::err_imported_module_relocated)
3178 if (ASTReadResult
Result =
3179 ReadModuleMapFileBlock(
Record, F, ImportedBy, ClientLoadCapabilities))
3185 NumUserInputs =
Record[1];
3187 (
const llvm::support::unaligned_uint64_t *)Blob.data();
3196llvm::Error ASTReader::ReadASTBlock(
ModuleFile &F,
3197 unsigned ClientLoadCapabilities) {
3198 BitstreamCursor &Stream = F.
Stream;
3200 if (llvm::Error Err = Stream.EnterSubBlock(
AST_BLOCK_ID))
3209 return MaybeEntry.takeError();
3210 llvm::BitstreamEntry Entry = MaybeEntry.get();
3212 switch (Entry.Kind) {
3213 case llvm::BitstreamEntry::Error:
3214 return llvm::createStringError(
3215 std::errc::illegal_byte_sequence,
3216 "error at end of module block in AST file");
3217 case llvm::BitstreamEntry::EndBlock:
3229 return llvm::Error::success();
3230 case llvm::BitstreamEntry::SubBlock:
3238 if (llvm::Error Err = Stream.SkipBlock())
3240 if (llvm::Error Err = ReadBlockAbbrevs(
3247 if (!PP.getExternalSource())
3248 PP.setExternalSource(
this);
3250 if (llvm::Error Err = Stream.SkipBlock())
3252 if (llvm::Error Err =
3261 if (llvm::Error Err = Stream.SkipBlock()) {
3270 if (!PP.getPreprocessingRecord())
3271 PP.createPreprocessingRecord();
3272 if (!PP.getPreprocessingRecord()->getExternalSource())
3273 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3277 if (llvm::Error Err = ReadSourceManagerBlock(F))
3282 if (llvm::Error Err = ReadSubmoduleBlock(F, ClientLoadCapabilities))
3287 BitstreamCursor
C = Stream;
3289 if (llvm::Error Err = Stream.SkipBlock())
3293 CommentsCursors.push_back(std::make_pair(
C, &F));
3298 if (llvm::Error Err = Stream.SkipBlock())
3304 case llvm::BitstreamEntry::Record:
3313 Stream.readRecord(Entry.ID,
Record, &Blob);
3314 if (!MaybeRecordType)
3315 return MaybeRecordType.takeError();
3347 return llvm::createStringError(
3348 std::errc::illegal_byte_sequence,
3349 "duplicate TYPE_OFFSET record in AST file");
3352 unsigned LocalBaseTypeIndex =
Record[1];
3357 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3361 std::make_pair(LocalBaseTypeIndex,
3371 return llvm::createStringError(
3372 std::errc::illegal_byte_sequence,
3373 "duplicate DECL_OFFSET record in AST file");
3376 unsigned LocalBaseDeclID =
Record[1];
3382 GlobalDeclMap.insert(
3388 std::make_pair(LocalBaseDeclID, F.
BaseDeclID - LocalBaseDeclID));
3400 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3401 LexicalContents Contents(
3402 reinterpret_cast<const llvm::support::unaligned_uint32_t *
>(
3404 static_cast<unsigned int>(Blob.size() / 4));
3405 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3413 auto *
Data = (
const unsigned char*)Blob.data();
3414 PendingVisibleUpdates[
ID].push_back(PendingVisibleUpdate{&F,
Data});
3417 if (
Decl *D = GetExistingDecl(ID))
3418 PendingUpdateRecords.push_back(
3419 PendingUpdateRecord(ID, D,
false));
3425 reinterpret_cast<const unsigned char *
>(Blob.data());
3433 PP.getIdentifierTable().setExternalIdentifierLookup(
this);
3439 return llvm::createStringError(
3440 std::errc::illegal_byte_sequence,
3441 "duplicate IDENTIFIER_OFFSET record in AST file");
3444 unsigned LocalBaseIdentifierID =
Record[1];
3450 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3456 std::make_pair(LocalBaseIdentifierID,
3459 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3472 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3473 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F,
Record[I]));
3480 getContext().getLangOpts().BuildingPCHWithObjectFile)
3481 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3482 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F,
Record[I]));
3486 if (SpecialTypes.empty()) {
3487 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3488 SpecialTypes.push_back(getGlobalTypeID(F,
Record[I]));
3492 if (SpecialTypes.size() !=
Record.size())
3493 return llvm::createStringError(std::errc::illegal_byte_sequence,
3494 "invalid special-types record");
3496 for (
unsigned I = 0, N =
Record.size(); I != N; ++I) {
3498 if (!SpecialTypes[I])
3499 SpecialTypes[I] =
ID;
3506 TotalNumStatements +=
Record[0];
3507 TotalNumMacros +=
Record[1];
3508 TotalLexicalDeclContexts +=
Record[2];
3509 TotalVisibleDeclContexts +=
Record[3];
3513 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3514 UnusedFileScopedDecls.push_back(getGlobalDeclID(F,
Record[I]));
3518 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3519 DelegatingCtorDecls.push_back(getGlobalDeclID(F,
Record[I]));
3523 if (
Record.size() % 3 != 0)
3524 return llvm::createStringError(std::errc::illegal_byte_sequence,
3525 "invalid weak identifiers record");
3529 WeakUndeclaredIdentifiers.clear();
3532 for (
unsigned I = 0, N =
Record.size(); I < N; ) {
3533 WeakUndeclaredIdentifiers.push_back(
3534 getGlobalIdentifierID(F,
Record[I++]));
3535 WeakUndeclaredIdentifiers.push_back(
3536 getGlobalIdentifierID(F,
Record[I++]));
3537 WeakUndeclaredIdentifiers.push_back(
3538 ReadSourceLocation(F,
Record, I).getRawEncoding());
3545 unsigned LocalBaseSelectorID =
Record[1];
3551 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3556 std::make_pair(LocalBaseSelectorID,
3568 = ASTSelectorLookupTable::Create(
3572 TotalNumMethodPoolEntries +=
Record[1];
3577 for (
unsigned Idx = 0, N =
Record.size() - 1; Idx < N; ) {
3578 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3580 ReferencedSelectorsData.push_back(ReadSourceLocation(F,
Record, Idx).
3589 PP.setPreambleRecordedPragmaAssumeNonNullLoc(
3590 ReadSourceLocation(F,
Record, Idx));
3596 unsigned Idx = 0, End =
Record.size() - 1;
3597 bool ReachedEOFWhileSkipping =
Record[Idx++];
3598 std::optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3599 if (ReachedEOFWhileSkipping) {
3602 bool FoundNonSkipPortion =
Record[Idx++];
3603 bool FoundElse =
Record[Idx++];
3605 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3606 FoundElse, ElseLoc);
3610 auto Loc = ReadSourceLocation(F,
Record, Idx);
3611 bool WasSkipping =
Record[Idx++];
3612 bool FoundNonSkip =
Record[Idx++];
3613 bool FoundElse =
Record[Idx++];
3614 ConditionalStack.push_back(
3615 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3617 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3622 if (!
Record.empty() && Listener)
3640 if (!Diags.isDiagnosticInFlight()) {
3642 SourceMgr.noteSLocAddressSpaceUsage(Diags);
3644 return llvm::createStringError(std::errc::invalid_argument,
3645 "ran out of source locations");
3650 unsigned RangeStart =
3652 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3657 GlobalSLocOffsetMap.insert(
3659 - SLocSpaceSize,&F));
3677 ParseLineTable(F,
Record);
3681 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3682 ExtVectorDecls.push_back(getGlobalDeclID(F,
Record[I]));
3686 if (
Record.size() % 3 != 0)
3687 return llvm::createStringError(std::errc::illegal_byte_sequence,
3688 "Invalid VTABLE_USES record");
3695 for (
unsigned Idx = 0, N =
Record.size(); Idx != N; ) {
3696 VTableUses.push_back(getGlobalDeclID(F,
Record[Idx++]));
3697 VTableUses.push_back(
3698 ReadSourceLocation(F,
Record, Idx).getRawEncoding());
3699 VTableUses.push_back(
Record[Idx++]);
3704 if (PendingInstantiations.size() % 2 != 0)
3705 return llvm::createStringError(
3706 std::errc::illegal_byte_sequence,
3707 "Invalid existing PendingInstantiations");
3709 if (
Record.size() % 2 != 0)
3710 return llvm::createStringError(
3711 std::errc::illegal_byte_sequence,
3712 "Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3714 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3715 PendingInstantiations.push_back(getGlobalDeclID(F,
Record[I++]));
3716 PendingInstantiations.push_back(
3717 ReadSourceLocation(F,
Record, I).getRawEncoding());
3723 return llvm::createStringError(std::errc::illegal_byte_sequence,
3724 "Invalid SEMA_DECL_REFS block");
3725 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3726 SemaDeclRefs.push_back(getGlobalDeclID(F,
Record[I]));
3734 unsigned LocalBasePreprocessedEntityID =
Record[0];
3736 unsigned StartingID;
3737 if (!PP.getPreprocessingRecord())
3738 PP.createPreprocessingRecord();
3739 if (!PP.getPreprocessingRecord()->getExternalSource())
3740 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3742 = PP.getPreprocessingRecord()
3749 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3754 std::make_pair(LocalBasePreprocessedEntityID,
3766 if (!PP.getPreprocessingRecord())
3767 PP.createPreprocessingRecord();
3768 if (!PP.getPreprocessingRecord()->getExternalSource())
3769 PP.getPreprocessingRecord()->SetExternalSource(*
this);
3774 GlobalSkippedRangeMap.insert(
3780 if (
Record.size() % 2 != 0)
3781 return llvm::createStringError(
3782 std::errc::illegal_byte_sequence,
3783 "invalid DECL_UPDATE_OFFSETS block in AST file");
3784 for (
unsigned I = 0, N =
Record.size(); I != N; I += 2) {
3786 DeclUpdateOffsets[
ID].push_back(std::make_pair(&F,
Record[I + 1]));
3790 if (
Decl *D = GetExistingDecl(ID))
3791 PendingUpdateRecords.push_back(
3792 PendingUpdateRecord(ID, D,
false));
3798 return llvm::createStringError(
3799 std::errc::illegal_byte_sequence,
3800 "duplicate OBJC_CATEGORIES_MAP record in AST file");
3813 CUDASpecialDeclRefs.clear();
3814 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3815 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F,
Record[I]));
3823 = HeaderFileInfoLookupTable::Create(
3827 &PP.getHeaderSearchInfo(),
3828 Blob.data() +
Record[2]));
3830 PP.getHeaderSearchInfo().SetExternalSource(
this);
3831 if (!PP.getHeaderSearchInfo().getExternalLookup())
3832 PP.getHeaderSearchInfo().SetExternalLookup(
this);
3838 FPPragmaOptions.swap(
Record);
3842 for (
unsigned I = 0, E =
Record.size(); I != E; ) {
3843 auto Name = ReadString(
Record, I);
3844 auto &OptInfo = OpenCLExtensions.OptMap[Name];
3845 OptInfo.Supported =
Record[I++] != 0;
3846 OptInfo.Enabled =
Record[I++] != 0;
3847 OptInfo.WithPragma =
Record[I++] != 0;
3848 OptInfo.Avail =
Record[I++];
3849 OptInfo.Core =
Record[I++];
3850 OptInfo.Opt =
Record[I++];
3855 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3856 TentativeDefinitions.push_back(getGlobalDeclID(F,
Record[I]));
3860 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3861 KnownNamespaces.push_back(getGlobalDeclID(F,
Record[I]));
3865 if (UndefinedButUsed.size() % 2 != 0)
3866 return llvm::createStringError(std::errc::illegal_byte_sequence,
3867 "Invalid existing UndefinedButUsed");
3869 if (
Record.size() % 2 != 0)
3870 return llvm::createStringError(std::errc::illegal_byte_sequence,
3871 "invalid undefined-but-used record");
3872 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3873 UndefinedButUsed.push_back(getGlobalDeclID(F,
Record[I++]));
3874 UndefinedButUsed.push_back(
3875 ReadSourceLocation(F,
Record, I).getRawEncoding());
3880 for (
unsigned I = 0, N =
Record.size(); I != N;) {
3881 DelayedDeleteExprs.push_back(getGlobalDeclID(F,
Record[I++]));
3883 DelayedDeleteExprs.push_back(Count);
3884 for (uint64_t
C = 0;
C < Count; ++
C) {
3885 DelayedDeleteExprs.push_back(ReadSourceLocation(F,
Record, I).getRawEncoding());
3886 bool IsArrayForm =
Record[I++] == 1;
3887 DelayedDeleteExprs.push_back(IsArrayForm);
3897 for (
unsigned I = 0, N =
Record.size(); I != N; ) {
3898 unsigned GlobalID = getGlobalSubmoduleID(F,
Record[I++]);
3901 PendingImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3902 if (DeserializationListener)
3903 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3911 return llvm::createStringError(
3912 std::errc::illegal_byte_sequence,
3913 "duplicate MACRO_OFFSET record in AST file");
3916 unsigned LocalBaseMacroID =
Record[1];
3922 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3926 std::make_pair(LocalBaseMacroID,
3935 LateParsedTemplates.emplace_back(
3936 std::piecewise_construct, std::forward_as_tuple(&F),
3942 return llvm::createStringError(std::errc::illegal_byte_sequence,
3943 "invalid pragma optimize record");
3944 OptimizeOffPragmaLocation = ReadSourceLocation(F,
Record[0]);
3949 return llvm::createStringError(std::errc::illegal_byte_sequence,
3950 "invalid pragma ms_struct record");
3951 PragmaMSStructState =
Record[0];
3956 return llvm::createStringError(
3957 std::errc::illegal_byte_sequence,
3958 "invalid pragma pointers to members record");
3959 PragmaMSPointersToMembersState =
Record[0];
3960 PointersToMembersPragmaLocation = ReadSourceLocation(F,
Record[1]);
3964 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
3965 UnusedLocalTypedefNameCandidates.push_back(
3966 getGlobalDeclID(F,
Record[I]));
3971 return llvm::createStringError(std::errc::illegal_byte_sequence,
3972 "invalid cuda pragma options record");
3973 ForceCUDAHostDeviceDepth =
Record[0];
3978 return llvm::createStringError(std::errc::illegal_byte_sequence,
3979 "invalid pragma pack record");
3980 PragmaAlignPackCurrentValue = ReadAlignPackInfo(
Record[0]);
3981 PragmaAlignPackCurrentLocation = ReadSourceLocation(F,
Record[1]);
3982 unsigned NumStackEntries =
Record[2];
3985 PragmaAlignPackStack.clear();
3986 for (
unsigned I = 0; I < NumStackEntries; ++I) {
3987 PragmaAlignPackStackEntry Entry;
3988 Entry.Value = ReadAlignPackInfo(
Record[Idx++]);
3989 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
3990 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
3991 PragmaAlignPackStrings.push_back(ReadString(
Record, Idx));
3992 Entry.SlotLabel = PragmaAlignPackStrings.back();
3993 PragmaAlignPackStack.push_back(Entry);
4000 return llvm::createStringError(std::errc::illegal_byte_sequence,
4001 "invalid pragma float control record");
4003 FpPragmaCurrentLocation = ReadSourceLocation(F,
Record[1]);
4004 unsigned NumStackEntries =
Record[2];
4007 FpPragmaStack.clear();
4008 for (
unsigned I = 0; I < NumStackEntries; ++I) {
4009 FpPragmaStackEntry Entry;
4011 Entry.Location = ReadSourceLocation(F,
Record[Idx++]);
4012 Entry.PushLocation = ReadSourceLocation(F,
Record[Idx++]);
4013 FpPragmaStrings.push_back(ReadString(
Record, Idx));
4014 Entry.SlotLabel = FpPragmaStrings.back();
4015 FpPragmaStack.push_back(Entry);
4021 for (
unsigned I = 0, N =
Record.size(); I != N; ++I)
4022 DeclsToCheckForDeferredDiags.insert(getGlobalDeclID(F,
Record[I]));
4028void ASTReader::ReadModuleOffsetMap(
ModuleFile &F)
const {
4043 using SLocRemapBuilder =
4056 while (
Data < DataEnd) {
4060 using namespace llvm::support;
4062 endian::readNext<uint8_t, llvm::endianness::little, unaligned>(
Data));
4064 endian::readNext<uint16_t, llvm::endianness::little, unaligned>(
Data);
4065 StringRef Name = StringRef((
const char*)
Data, Len);
4069 ? ModuleMgr.lookupByModuleName(Name)
4070 : ModuleMgr.lookupByFileName(Name));
4073 "SourceLocation remap refers to unknown module, cannot find ";
4074 Msg.append(std::string(Name));
4080 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4081 uint32_t IdentifierIDOffset =
4082 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4083 uint32_t MacroIDOffset =
4084 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4085 uint32_t PreprocessedEntityIDOffset =
4086 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4087 uint32_t SubmoduleIDOffset =
4088 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4089 uint32_t SelectorIDOffset =
4090 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4091 uint32_t DeclIDOffset =
4092 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4093 uint32_t TypeIndexOffset =
4094 endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
Data);
4096 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
4097 RemapBuilder &Remap) {
4098 constexpr uint32_t
None = std::numeric_limits<uint32_t>::max();
4100 Remap.insert(std::make_pair(Offset,
4101 static_cast<int>(BaseOffset - Offset)));
4105 std::numeric_limits<SourceLocation::UIntTy>::max();
4106 if (SLocOffset != SLocNone)
4112 mapOffset(MacroIDOffset, OM->
BaseMacroID, MacroRemap);
4114 PreprocessedEntityRemap);
4117 mapOffset(DeclIDOffset, OM->
BaseDeclID, DeclRemap);
4128 unsigned ClientLoadCapabilities) {
4137 "MODULE_NAME should come before MODULE_MAP_FILE");
4138 if (PP.getPreprocessorOpts().ModulesCheckRelocated &&
4144 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
4146 M ? Map.getModuleMapFileForUniquing(M) : std::nullopt;
4148 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
4151 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities)) {
4152 if (
auto ASTFE = M ? M->
getASTFile() : std::nullopt) {
4155 << ASTFE->getName();
4158 Diag(diag::err_imported_module_not_found)
4166 Diag(diag::note_imported_by_pch_module_not_found)
4173 assert(M && M->
Name == F.
ModuleName &&
"found module with different name");
4177 if (!StoredModMap || *StoredModMap != ModMap) {
4178 assert(ModMap &&
"found module is missing module map file");
4180 "top-level import should be verified");
4182 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4183 Diag(diag::err_imported_module_modmap_changed)
4190 for (
unsigned I = 0, N =
Record[Idx++]; I < N; ++I) {
4195 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4196 Error(
"could not find file '" +
Filename +
"' referenced by AST file");
4199 AdditionalStoredMaps.insert(*SF);
4204 if (
auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
4208 if (!AdditionalStoredMaps.erase(ModMap)) {
4209 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4210 Diag(diag::err_module_different_modmap)
4220 if (!canRecoverFromOutOfDate(F.
FileName, ClientLoadCapabilities))
4221 Diag(diag::err_module_different_modmap)
4242 : Known->second.second;
4244 for (
ObjCMethodList *List = &Start; List; List = List->getNext()) {
4246 if (List->getMethod() == Method) {
4254 if (List->getNext())
4255 List->setMethod(List->getNext()->getMethod());
4257 List->setMethod(Method);
4263 for (
Decl *D : Names) {
4264 bool wasHidden = !D->isUnconditionallyVisible();
4265 D->setVisibleDespiteOwningModule();
4267 if (wasHidden && SemaObj) {
4280 Stack.push_back(Mod);
4281 while (!Stack.empty()) {
4282 Mod = Stack.pop_back_val();
4284 if (NameVisibility <= Mod->NameVisibility) {
4300 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4301 if (Hidden != HiddenNamesMap.end()) {
4303 HiddenNamesMap.erase(Hidden);
4305 assert(!HiddenNamesMap.contains(Mod) &&
4306 "making names visible added hidden names");
4313 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4315 if (
Visited.insert(Exported).second)
4316 Stack.push_back(Exported);
4331 getContext().mergeDefinitionIntoModule(
4334 PendingMergedDefinitionsToDeduplicate.insert(Def);
4343 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4344 !PP.getLangOpts().Modules)
4348 TriedLoadingGlobalIndex =
true;
4349 StringRef ModuleCachePath
4350 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4351 std::pair<GlobalModuleIndex *, llvm::Error>
Result =
4353 if (llvm::Error Err = std::move(
Result.second)) {
4355 consumeError(std::move(Err));
4359 GlobalIndex.reset(
Result.first);
4360 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4365 return PP.getLangOpts().Modules && UseGlobalIndex &&
4366 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4373 llvm::raw_fd_ostream OS(TimestampFilename, EC,
4374 llvm::sys::fs::OF_TextWithCRLF);
4377 OS <<
"Timestamp file\n";
4390 consumeError(MaybeEntry.takeError());
4393 llvm::BitstreamEntry Entry = MaybeEntry.get();
4395 switch (Entry.Kind) {
4396 case llvm::BitstreamEntry::Error:
4397 case llvm::BitstreamEntry::EndBlock:
4400 case llvm::BitstreamEntry::Record:
4406 consumeError(Skipped.takeError());
4410 case llvm::BitstreamEntry::SubBlock:
4411 if (Entry.ID == BlockID) {
4412 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4414 consumeError(std::move(Err));
4421 if (llvm::Error Err = Cursor.SkipBlock()) {
4423 consumeError(std::move(Err));
4432 unsigned ClientLoadCapabilities,
4434 llvm::TimeTraceScope scope(
"ReadAST",
FileName);
4438 CurrentDeserializingModuleKind,
Type);
4444 unsigned PreviousGeneration = 0;
4446 PreviousGeneration = incrementGeneration(*ContextObj);
4448 unsigned NumModules = ModuleMgr.size();
4453 ClientLoadCapabilities)) {
4454 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules);
4458 GlobalIndex.reset();
4459 ModuleMgr.setGlobalIndex(
nullptr);
4463 if (NewLoadedModuleFile && !Loaded.empty())
4464 *NewLoadedModuleFile = Loaded.back().Mod;
4475 for (ImportedModule &M : Loaded) {
4477 llvm::TimeTraceScope Scope2(
"Read Loaded AST", F.
ModuleName);
4480 if (llvm::Error Err = ReadASTBlock(F, ClientLoadCapabilities)) {
4481 Error(std::move(Err));
4487 Error(diag::err_module_file_missing_top_level_submodule, F.
FileName);
4493 if (llvm::Error Err = ReadExtensionBlock(F)) {
4494 Error(std::move(Err));
4507 for (ImportedModule &M : Loaded) {
4523 if (!PP.getLangOpts().CPlusPlus) {
4530 auto It = PP.getIdentifierTable().find(Key);
4531 if (It == PP.getIdentifierTable().end())
4540 II = &PP.getIdentifierTable().getOwn(Key);
4551 SetIdentifierInfo(ID, II);
4558 for (
auto &
Id : PP.getIdentifierTable())
4559 Id.second->setOutOfDate(
true);
4562 for (
const auto &Sel : SelectorGeneration)
4563 SelectorOutOfDate[Sel.first] =
true;
4567 for (ImportedModule &M : Loaded) {
4570 ModuleMgr.moduleFileAccepted(&F);
4579 F.
ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4583 for (
unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4584 UnresolvedModuleRef &
Unresolved = UnresolvedModuleRefs[I];
4586 Module *ResolvedMod = getSubmodule(GlobalID);
4589 case UnresolvedModuleRef::Conflict:
4592 Conflict.
Other = ResolvedMod;
4594 Unresolved.Mod->Conflicts.push_back(Conflict);
4598 case UnresolvedModuleRef::Import:
4603 case UnresolvedModuleRef::Affecting:
4605 Unresolved.Mod->AffectingClangModules.insert(ResolvedMod);
4608 case UnresolvedModuleRef::Export:
4615 UnresolvedModuleRefs.clear();
4622 InitializeContext();
4627 if (DeserializationListener)
4628 DeserializationListener->ReaderInitialized(
this);
4630 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4645 for (
unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4646 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4647 ObjCClassesLoaded[I],
4648 PreviousGeneration);
4657 for (
unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4658 ImportedModule &M = Loaded[I];
4675 if (!Stream.canSkipToPos(4))
4676 return llvm::createStringError(std::errc::illegal_byte_sequence,
4677 "file too small to contain AST file magic");
4678 for (
unsigned C : {
'C',
'P',
'C',
'H'})
4681 return llvm::createStringError(
4682 std::errc::illegal_byte_sequence,
4683 "file doesn't start with AST file magic");
4685 return Res.takeError();
4686 return llvm::Error::success();
4701 llvm_unreachable(
"unknown module kind");
4705ASTReader::ReadASTCore(StringRef
FileName,
4710 off_t ExpectedSize, time_t ExpectedModTime,
4712 unsigned ClientLoadCapabilities) {
4714 std::string ErrorStr;
4716 = ModuleMgr.addModule(
FileName,
Type, ImportLoc, ImportedBy,
4717 getGeneration(), ExpectedSize, ExpectedModTime,
4721 switch (AddResult) {
4723 Diag(diag::remark_module_import)
4725 << (ImportedBy ? StringRef(ImportedBy->
ModuleName) : StringRef());
4735 if (ClientLoadCapabilities & ARR_Missing)
4739 Diag(diag::err_ast_file_not_found)
4747 if (ClientLoadCapabilities & ARR_OutOfDate)
4751 Diag(diag::err_ast_file_out_of_date)
4757 assert(M &&
"Missing module file");
4759 bool ShouldFinalizePCM =
false;
4760 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4761 auto &MC = getModuleManager().getModuleCache();
4762 if (ShouldFinalizePCM)
4768 BitstreamCursor &Stream = F.
Stream;
4769 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4770 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4774 Diag(diag::err_ast_file_invalid)
4780 bool HaveReadControlBlock =
false;
4784 Error(MaybeEntry.takeError());
4787 llvm::BitstreamEntry Entry = MaybeEntry.get();
4789 switch (Entry.Kind) {
4790 case llvm::BitstreamEntry::Error:
4791 case llvm::BitstreamEntry::Record:
4792 case llvm::BitstreamEntry::EndBlock:
4793 Error(
"invalid record at top-level of AST file");
4796 case llvm::BitstreamEntry::SubBlock:
4802 HaveReadControlBlock =
true;
4803 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4811 F.ModuleName.empty()) {
4813 if (
Result != OutOfDate ||
4814 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4820 case Failure:
return Failure;
4821 case Missing:
return Missing;
4822 case OutOfDate:
return OutOfDate;
4824 case ConfigurationMismatch:
return ConfigurationMismatch;
4825 case HadErrors:
return HadErrors;
4830 if (!HaveReadControlBlock) {
4831 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4832 Diag(diag::err_pch_version_too_old);
4837 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4838 ShouldFinalizePCM =
true;
4842 if (llvm::Error Err = Stream.SkipBlock()) {
4843 Error(std::move(Err));
4850 llvm_unreachable(
"unexpected break; expected return");
4854ASTReader::readUnhashedControlBlock(
ModuleFile &F,
bool WasImportedBy,
4855 unsigned ClientLoadCapabilities) {
4857 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4858 bool AllowCompatibleConfigurationMismatch =
4860 bool DisableValidation = shouldDisableValidationForFile(F);
4862 ASTReadResult
Result = readUnhashedControlBlockImpl(
4863 &F, F.
Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4869 if (DisableValidation || WasImportedBy ||
4870 (AllowConfigurationMismatch &&
Result == ConfigurationMismatch))
4874 Error(
"malformed block record in AST file");
4897 if (getModuleManager().getModuleCache().isPCMFinal(F.
FileName)) {
4898 Diag(diag::warn_module_system_bit_conflict) << F.
FileName;
4907 ModuleFile *F, llvm::StringRef StreamData,
unsigned ClientLoadCapabilities,
4909 bool ValidateDiagnosticOptions) {
4911 BitstreamCursor Stream(StreamData);
4916 consumeError(std::move(Err));
4931 consumeError(MaybeEntry.takeError());
4934 llvm::BitstreamEntry Entry = MaybeEntry.get();
4936 switch (Entry.Kind) {
4937 case llvm::BitstreamEntry::Error:
4938 case llvm::BitstreamEntry::SubBlock:
4941 case llvm::BitstreamEntry::EndBlock:
4944 case llvm::BitstreamEntry::Record:
4953 Stream.readRecord(Entry.ID,
Record, &Blob);
4954 if (!MaybeRecordType) {
4963 "Dummy AST file signature not backpatched in ASTWriter.");
4970 "Dummy AST block hash not backpatched in ASTWriter.");
4974 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4975 if (Listener && ValidateDiagnosticOptions &&
4976 !AllowCompatibleConfigurationMismatch &&
4977 ParseDiagnosticOptions(
Record, Complain, *Listener))
4982 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
4983 if (Listener && !AllowCompatibleConfigurationMismatch &&
4984 ParseHeaderSearchPaths(
Record, Complain, *Listener))
4985 Result = ConfigurationMismatch;
5014 if (
Record.size() < 4)
return true;
5019 unsigned BlockNameLen =
Record[2];
5020 unsigned UserInfoLen =
Record[3];
5022 if (BlockNameLen + UserInfoLen > Blob.size())
return true;
5024 Metadata.
BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
5025 Metadata.
UserInfo = std::string(Blob.data() + BlockNameLen,
5026 Blob.data() + BlockNameLen + UserInfoLen);
5030llvm::Error ASTReader::ReadExtensionBlock(
ModuleFile &F) {
5031 BitstreamCursor &Stream = F.
Stream;
5037 return MaybeEntry.takeError();
5038 llvm::BitstreamEntry Entry = MaybeEntry.get();
5040 switch (Entry.Kind) {
5041 case llvm::BitstreamEntry::SubBlock:
5042 if (llvm::Error Err = Stream.SkipBlock())
5045 case llvm::BitstreamEntry::EndBlock:
5046 return llvm::Error::success();
5047 case llvm::BitstreamEntry::Error:
5048 return llvm::createStringError(std::errc::illegal_byte_sequence,
5049 "malformed block record in AST file");
5050 case llvm::BitstreamEntry::Record:
5057 Stream.readRecord(Entry.ID,
Record, &Blob);
5059 return MaybeRecCode.takeError();
5060 switch (MaybeRecCode.get()) {
5064 return llvm::createStringError(
5065 std::errc::illegal_byte_sequence,
5066 "malformed EXTENSION_METADATA in AST file");
5069 auto Known = ModuleFileExtensions.find(Metadata.
BlockName);
5070 if (Known == ModuleFileExtensions.end())
break;
5073 if (
auto Reader = Known->second->createExtensionReader(Metadata, *
this,
5083 return llvm::Error::success();
5087 assert(ContextObj &&
"no context to initialize");
5091 if (DeserializationListener)
5101 if (!Context.CFConstantStringTypeDecl)
5108 Error(
"FILE type is NULL");
5112 if (!Context.FILEDecl) {
5118 Error(
"Invalid FILE type in AST file");
5127 QualType Jmp_bufType = GetType(Jmp_buf);
5128 if (Jmp_bufType.
isNull()) {
5129 Error(
"jmp_buf type is NULL");
5133 if (!Context.jmp_bufDecl) {
5139 Error(
"Invalid jmp_buf type in AST file");
5148 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
5149 if (Sigjmp_bufType.
isNull()) {
5150 Error(
"sigjmp_buf type is NULL");
5154 if (!Context.sigjmp_bufDecl) {
5159 assert(Tag &&
"Invalid sigjmp_buf type in AST file");
5165 if (
unsigned ObjCIdRedef
5167 if (Context.ObjCIdRedefinitionType.
isNull())
5168 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
5171 if (
unsigned ObjCClassRedef
5173 if (Context.ObjCClassRedefinitionType.
isNull())
5174 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
5177 if (
unsigned ObjCSelRedef
5179 if (Context.ObjCSelRedefinitionType.
isNull())
5180 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
5184 QualType Ucontext_tType = GetType(Ucontext_t);
5185 if (Ucontext_tType.
isNull()) {
5186 Error(
"ucontext_t type is NULL");
5190 if (!Context.ucontext_tDecl) {
5195 assert(Tag &&
"Invalid ucontext_t type in AST file");
5205 if (!CUDASpecialDeclRefs.empty()) {
5206 assert(CUDASpecialDeclRefs.size() == 1 &&
"More decl refs than expected!");
5208 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
5213 for (
auto &Import : PendingImportedModules) {
5214 if (
Module *Imported = getSubmodule(Import.ID)) {
5217 if (Import.ImportLoc.isValid())
5218 PP.makeModuleVisible(Imported, Import.ImportLoc);
5225 PendingImportedModulesSema.append(PendingImportedModules);
5226 PendingImportedModules.clear();
5236 BitstreamCursor Stream(
PCH);
5239 consumeError(std::move(Err));
5251 Stream.advanceSkippingSubblocks();
5254 consumeError(MaybeEntry.takeError());
5257 llvm::BitstreamEntry Entry = MaybeEntry.get();
5259 if (Entry.Kind != llvm::BitstreamEntry::Record)
5267 consumeError(MaybeRecord.takeError());
5273 "Dummy AST file signature not backpatched in ASTWriter.");
5283 const std::string &ASTFileName,
FileManager &FileMgr,
5289 Diags.
Report(diag::err_fe_unable_to_read_pch_file)
5290 << ASTFileName << Buffer.getError().message();
5291 return std::string();
5295 BitstreamCursor Stream(PCHContainerRdr.
ExtractPCH(**Buffer));
5299 Diags.
Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5300 return std::string();
5305 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5306 return std::string();
5313 Stream.advanceSkippingSubblocks();
5316 consumeError(MaybeEntry.takeError());
5317 return std::string();
5319 llvm::BitstreamEntry Entry = MaybeEntry.get();
5321 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5322 return std::string();
5324 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5325 Diags.
Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5326 return std::string();
5334 consumeError(MaybeRecord.takeError());
5335 return std::string();
5348 std::string ExistingModuleCachePath;
5350 bool StrictOptionMatches;
5353 SimplePCHValidator(
const LangOptions &ExistingLangOpts,
5356 StringRef ExistingModuleCachePath,
FileManager &FileMgr,
5357 bool StrictOptionMatches)
5358 : ExistingLangOpts(ExistingLangOpts),
5359 ExistingTargetOpts(ExistingTargetOpts),
5360 ExistingPPOpts(ExistingPPOpts),
5361 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr),
5362 StrictOptionMatches(StrictOptionMatches) {}
5364 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
5365 bool AllowCompatibleDifferences)
override {
5367 AllowCompatibleDifferences);
5370 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
5371 bool AllowCompatibleDifferences)
override {
5373 AllowCompatibleDifferences);
5377 StringRef SpecificModuleCachePath,
5378 bool Complain)
override {
5380 ExistingModuleCachePath,
nullptr,
5381 ExistingLangOpts, ExistingPPOpts);
5385 bool ReadMacros,
bool Complain,
5386 std::string &SuggestedPredefines)
override {
5388 PPOpts, ExistingPPOpts, ReadMacros,
nullptr, FileMgr,
5389 SuggestedPredefines, ExistingLangOpts,
5402 unsigned ClientLoadCapabilities) {
5404 std::unique_ptr<llvm::MemoryBuffer> OwnedBuffer;
5416 OwnedBuffer = std::move(*BufferOrErr);
5417 Buffer = OwnedBuffer.get();
5421 StringRef Bytes = PCHContainerRdr.
ExtractPCH(*Buffer);
5422 BitstreamCursor Stream(Bytes);
5426 consumeError(std::move(Err));
5437 BitstreamCursor InputFilesCursor;
5438 uint64_t InputFilesOffsetBase = 0;
5441 std::string ModuleDir;
5442 bool DoneWithControlBlock =
false;
5443 while (!DoneWithControlBlock) {
5447 consumeError(MaybeEntry.takeError());
5450 llvm::BitstreamEntry Entry = MaybeEntry.get();
5452 switch (Entry.Kind) {
5453 case llvm::BitstreamEntry::SubBlock: {
5456 std::string IgnoredSuggestedPredefines;
5457 if (ReadOptionsBlock(Stream, ClientLoadCapabilities,
5459 Listener, IgnoredSuggestedPredefines) !=
Success)
5465 InputFilesCursor = Stream;
5466 if (llvm::Error Err = Stream.SkipBlock()) {
5468 consumeError(std::move(Err));
5471 if (NeedsInputFiles &&
5474 InputFilesOffsetBase = InputFilesCursor.GetCurrentBitNo();
5478 if (llvm::Error Err = Stream.SkipBlock()) {
5480 consumeError(std::move(Err));
5489 case llvm::BitstreamEntry::EndBlock:
5490 DoneWithControlBlock =
true;
5493 case llvm::BitstreamEntry::Error:
5496 case llvm::BitstreamEntry::Record:
5500 if (DoneWithControlBlock)
break;
5505 Stream.readRecord(Entry.ID,
Record, &Blob);
5506 if (!MaybeRecCode) {
5521 ModuleDir = std::string(Blob);
5525 auto Path = ReadString(
Record, Idx);
5526 ResolveImportedPath(Path, ModuleDir);
5531 if (!NeedsInputFiles)
5534 unsigned NumInputFiles =
Record[0];
5535 unsigned NumUserFiles =
Record[1];
5536 const llvm::support::unaligned_uint64_t *InputFileOffs =
5537 (
const llvm::support::unaligned_uint64_t *)Blob.data();
5538 for (
unsigned I = 0; I != NumInputFiles; ++I) {
5540 bool isSystemFile = I >= NumUserFiles;
5542 if (isSystemFile && !NeedsSystemInputFiles)
5545 BitstreamCursor &Cursor = InputFilesCursor;
5547 if (llvm::Error Err =
5548 Cursor.JumpToBit(InputFilesOffsetBase + InputFileOffs[I])) {
5550 consumeError(std::move(Err));
5556 consumeError(MaybeCode.takeError());
5558 unsigned Code = MaybeCode.get();
5562 bool shouldContinue =
false;
5564 Cursor.readRecord(Code,
Record, &Blob);
5565 if (!MaybeRecordType) {
5567 consumeError(MaybeRecordType.takeError());
5573 bool Overridden =
static_cast<bool>(
Record[3]);
5574 std::string
Filename = std::string(Blob);
5575 ResolveImportedPath(
Filename, ModuleDir);
5577 Filename, isSystemFile, Overridden,
false);
5580 if (!shouldContinue)
5590 unsigned Idx = 0, N =
Record.size();
5596 bool IsStandardCXXModule =
Record[Idx++];
5603 if (IsStandardCXXModule) {
5604 std::string ModuleName = ReadString(
Record, Idx);
5611 std::string ModuleName = ReadString(
Record, Idx);
5613 ResolveImportedPath(
Filename, ModuleDir);
5626 if (FindModuleFileExtensions) {
5627 BitstreamCursor SavedStream = Stream;
5629 bool DoneWithExtensionBlock =
false;
5630 while (!DoneWithExtensionBlock) {
5636 llvm::BitstreamEntry Entry = MaybeEntry.get();
5638 switch (Entry.Kind) {
5639 case llvm::BitstreamEntry::SubBlock:
5640 if (llvm::Error Err = Stream.SkipBlock()) {
5642 consumeError(std::move(Err));
5647 case llvm::BitstreamEntry::EndBlock:
5648 DoneWithExtensionBlock =
true;
5651 case llvm::BitstreamEntry::Error:
5654 case llvm::BitstreamEntry::Record:
5661 Stream.readRecord(Entry.ID,
Record, &Blob);
5662 if (!MaybeRecCode) {
5666 switch (MaybeRecCode.get()) {
5678 Stream = SavedStream;
5682 if (readUnhashedControlBlockImpl(
5683 nullptr, Bytes, ClientLoadCapabilities,
5685 ValidateDiagnosticOptions) !=
Success)
5697 StringRef ExistingModuleCachePath,
5698 bool RequireStrictOptionMatches) {
5699 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
5700 ExistingModuleCachePath, FileMgr,
5701 RequireStrictOptionMatches);
5702 return !readASTFileControlBlock(
Filename, FileMgr, ModuleCache,
5708llvm::Error ASTReader::ReadSubmoduleBlock(
ModuleFile &F,
5709 unsigned ClientLoadCapabilities) {
5714 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5716 Module *CurrentModule =
nullptr;
5720 F.
Stream.advanceSkippingSubblocks();
5722 return MaybeEntry.takeError();
5723 llvm::BitstreamEntry Entry = MaybeEntry.get();
5725 switch (Entry.Kind) {
5726 case llvm::BitstreamEntry::SubBlock:
5727 case llvm::BitstreamEntry::Error:
5728 return llvm::createStringError(std::errc::illegal_byte_sequence,
5729 "malformed block record in AST file");
5730 case llvm::BitstreamEntry::EndBlock:
5731 return llvm::Error::success();
5732 case llvm::BitstreamEntry::Record:
5742 return MaybeKind.takeError();
5743 unsigned Kind = MaybeKind.get();
5746 return llvm::createStringError(
5747 std::errc::illegal_byte_sequence,
5748 "submodule metadata record should be at beginning of block");
5763 return llvm::createStringError(std::errc::illegal_byte_sequence,
5764 "malformed module definition");
5766 StringRef Name = Blob;
5772 bool IsFramework =
Record[Idx++];
5773 bool IsExplicit =
Record[Idx++];
5774 bool IsSystem =
Record[Idx++];
5775 bool IsExternC =
Record[Idx++];
5776 bool InferSubmodules =
Record[Idx++];
5777 bool InferExplicitSubmodules =
Record[Idx++];
5778 bool InferExportWildcard =
Record[Idx++];
5779 bool ConfigMacrosExhaustive =
Record[Idx++];
5780 bool ModuleMapIsPrivate =
Record[Idx++];
5781 bool NamedModuleHasInit =
Record[Idx++];
5783 Module *ParentModule =
nullptr;
5785 ParentModule = getSubmodule(
Parent);
5796 if (GlobalIndex >= SubmodulesLoaded.size() ||
5797 SubmodulesLoaded[GlobalIndex])
5798 return llvm::createStringError(std::errc::invalid_argument,
5799 "too many submodules");
5801 if (!ParentModule) {
5804 if (!
bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
5806 CurFile != F.
File) {
5807 auto ConflictError =
5809 ContextObj->DiagAllocator)
5833 if (DeserializationListener)
5834 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5836 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5861 std::string
Filename = std::string(Blob);
5863 if (
auto Umbrella = PP.getFileManager().getOptionalFileRef(
Filename)) {
5891 std::string HeaderName(Blob);
5892 ResolveImportedPath(F, HeaderName);
5899 std::string Dirname = std::string(Blob);
5900 ResolveImportedPath(F, Dirname);
5902 PP.getFileManager().getOptionalDirectoryRef(Dirname)) {
5914 unsigned LocalBaseSubmoduleID =
Record[1];
5918 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5923 std::make_pair(LocalBaseSubmoduleID,
5932 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5937 Unresolved.Kind = UnresolvedModuleRef::Import;
5944 for (
unsigned Idx = 0; Idx !=
Record.size(); ++Idx) {
5949 Unresolved.Kind = UnresolvedModuleRef::Affecting;
5956 for (
unsigned Idx = 0; Idx + 1 <
Record.size(); Idx += 2) {
5961 Unresolved.Kind = UnresolvedModuleRef::Export;
5973 PP.getTargetInfo());
5991 Unresolved.Kind = UnresolvedModuleRef::Conflict;
6003 Inits.push_back(getGlobalDeclID(F, ID));
6004 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
6023bool ASTReader::ParseLanguageOptions(
const RecordData &
Record,
6026 bool AllowCompatibleDifferences) {
6029#define LANGOPT(Name, Bits, Default, Description) \
6030 LangOpts.Name = Record[Idx++];
6031#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
6032 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
6033#include "clang/Basic/LangOptions.def"
6034#define SANITIZER(NAME, ID) \
6035 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
6036#include "clang/Basic/Sanitizers.def"
6038 for (
unsigned N =
Record[Idx++]; N; --N)
6042 VersionTuple runtimeVersion = ReadVersionTuple(
Record, Idx);
6048 for (
unsigned N =
Record[Idx++]; N; --N) {
6050 ReadString(
Record, Idx));
6055 for (
unsigned N =
Record[Idx++]; N; --N) {
6062 AllowCompatibleDifferences);
6065bool ASTReader::ParseTargetOptions(
const RecordData &
Record,
bool Complain,
6067 bool AllowCompatibleDifferences) {
6071 TargetOpts.
CPU = ReadString(
Record, Idx);
6073 TargetOpts.
ABI = ReadString(
Record, Idx);
6074 for (
unsigned N =
Record[Idx++]; N; --N) {
6077 for (
unsigned N =
Record[Idx++]; N; --N) {
6082 AllowCompatibleDifferences);
6085bool ASTReader::ParseDiagnosticOptions(
const RecordData &
Record,
bool Complain,
6089#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
6090#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
6091 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
6092#include "clang/Basic/DiagnosticOptions.def"
6094 for (
unsigned N =
Record[Idx++]; N; --N)
6095 DiagOpts->Warnings.push_back(ReadString(
Record, Idx));
6096 for (
unsigned N =
Record[Idx++]; N; --N)
6097 DiagOpts->Remarks.push_back(ReadString(
Record, Idx));
6102bool ASTReader::ParseFileSystemOptions(
const RecordData &
Record,
bool Complain,
6110bool ASTReader::ParseHeaderSearchOptions(
const RecordData &
Record,
6128 std::string SpecificModuleCachePath = ReadString(
Record, Idx);
6134bool ASTReader::ParseHeaderSearchPaths(
const RecordData &
Record,
bool Complain,
6140 for (
unsigned N =
Record[Idx++]; N; --N) {
6141 std::string Path = ReadString(
Record, Idx);
6144 bool IsFramework =
Record[Idx++];
6145 bool IgnoreSysRoot =
Record[Idx++];
6151 for (
unsigned N =
Record[Idx++]; N; --N) {
6152 std::string Prefix = ReadString(
Record, Idx);
6153 bool IsSystemHeader =
Record[Idx++];
6158 for (
unsigned N =
Record[Idx++]; N; --N) {
6159 std::string VFSOverlayFile = ReadString(
Record, Idx);
6166bool ASTReader::ParsePreprocessorOptions(
const RecordData &
Record,
6169 std::string &SuggestedPredefines) {
6174 bool ReadMacros =
Record[Idx++];
6176 for (
unsigned N =
Record[Idx++]; N; --N) {
6178 bool IsUndef =
Record[Idx++];
6179 PPOpts.
Macros.push_back(std::make_pair(Macro, IsUndef));
6184 for (
unsigned N =
Record[Idx++]; N; --N) {
6189 for (
unsigned N =
Record[Idx++]; N; --N) {
6198 SuggestedPredefines.clear();
6200 SuggestedPredefines);
6203std::pair<ModuleFile *, unsigned>
6204ASTReader::getModulePreprocessedEntity(
unsigned GlobalIndex) {
6205 GlobalPreprocessedEntityMapType::iterator
6206 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
6207 assert(I != GlobalPreprocessedEntityMap.end() &&
6208 "Corrupted global preprocessed entity map");
6211 return std::make_pair(M, LocalIndex);
6214llvm::iterator_range<PreprocessingRecord::iterator>
6215ASTReader::getModulePreprocessedEntities(
ModuleFile &Mod)
const {
6224bool ASTReader::canRecoverFromOutOfDate(StringRef ModuleFileName,
6225 unsigned int ClientLoadCapabilities) {
6226 return ClientLoadCapabilities & ARR_OutOfDate &&
6227 !getModuleManager().getModuleCache().isPCMFinal(ModuleFileName);
6230llvm::iterator_range<ASTReader::ModuleDeclIterator>
6232 return llvm::make_range(
6239 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
6240 assert(I != GlobalSkippedRangeMap.end() &&
6241 "Corrupted global skipped range map");
6244 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
6247 TranslateSourceLocation(*M, RawRange.
getEnd()));
6248 assert(Range.isValid());
6254 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6256 unsigned LocalIndex = PPInfo.second;
6259 if (!PP.getPreprocessingRecord()) {
6260 Error(
"no preprocessing record");
6267 Error(std::move(Err));
6274 Error(MaybeEntry.takeError());
6277 llvm::BitstreamEntry Entry = MaybeEntry.get();
6279 if (Entry.Kind != llvm::BitstreamEntry::Record)
6284 TranslateSourceLocation(M, PPOffs.
getEnd()));
6290 if (!MaybeRecType) {
6291 Error(MaybeRecType.takeError());
6296 bool isBuiltin =
Record[0];
6300 Name = getLocalIdentifier(M,
Record[1]);
6303 getGlobalPreprocessedEntityID(M,
Record[1]);
6304 Def = cast<MacroDefinitionRecord>(
6305 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
6323 if (DeserializationListener)
6324 DeserializationListener->MacroDefinitionRead(PPID, MD);
6330 const char *FullFileNameStart = Blob.data() +
Record[0];
6331 StringRef FullFileName(FullFileNameStart, Blob.size() -
Record[0]);
6333 if (!FullFileName.empty())
6334 File = PP.getFileManager().getOptionalFileRef(FullFileName);
6341 StringRef(Blob.data(),
Record[0]),
6349 llvm_unreachable(
"Invalid PreprocessorDetailRecordTypes");
6359 GlobalSLocOffsetMapType::const_iterator SLocMapI)
const {
6361 for (GlobalSLocOffsetMapType::const_iterator
6362 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
6368 return getTotalNumPreprocessedEntities();
6373struct PPEntityComp {
6403 bool EndsAfter)
const {
6404 if (SourceMgr.isLocalSourceLocation(Loc))
6405 return getTotalNumPreprocessedEntities();
6407 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
6408 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
6409 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
6410 "Corrupted global sloc offset map");
6412 if (SLocMapI->second->NumPreprocessedEntities == 0)
6413 return findNextPreprocessedEntity(SLocMapI);
6424 pp_iterator
First = pp_begin;
6428 PPI = std::upper_bound(pp_begin, pp_end, Loc,
6429 PPEntityComp(*
this, M));
6438 std::advance(PPI,
Half);
6439 if (SourceMgr.isBeforeInTranslationUnit(
6440 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
6443 Count = Count -
Half - 1;
6450 return findNextPreprocessedEntity(SLocMapI);
6457std::pair<unsigned, unsigned>
6459 if (Range.isInvalid())
6460 return std::make_pair(0,0);
6461 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
6464 findPreprocessedEntity(Range.getBegin(),
false);
6466 return std::make_pair(BeginID, EndID);
6476 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6478 unsigned LocalIndex = PPInfo.second;
6485 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
6494 class HeaderFileInfoVisitor {
6496 std::optional<HeaderFileInfo> HFI;
6499 explicit HeaderFileInfoVisitor(
FileEntryRef FE) : FE(FE) {}
6508 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
6509 if (Pos == Table->end())
6516 std::optional<HeaderFileInfo> getHeaderFileInfo()
const {
return HFI; }
6522 HeaderFileInfoVisitor Visitor(FE);
6523 ModuleMgr.visit(Visitor);
6524 if (std::optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
6531 using DiagState = DiagnosticsEngine::DiagState;
6542 auto ReadDiagState = [&](
const DiagState &BasedOn,
6543 bool IncludeNonPragmaStates) {
6544 unsigned BackrefID =
Record[Idx++];
6546 return DiagStates[BackrefID - 1];
6549 Diag.DiagStates.push_back(BasedOn);
6550 DiagState *NewState = &
Diag.DiagStates.back();
6551 DiagStates.push_back(NewState);
6552 unsigned Size =
Record[Idx++];
6553 assert(Idx + Size * 2 <=
Record.size() &&
6554 "Invalid data, not enough diag/map pairs");
6556 unsigned DiagID =
Record[Idx++];
6559 if (!NewMapping.
isPragma() && !IncludeNonPragmaStates)
6572 Mapping = NewMapping;
6578 DiagState *FirstState;
6583 FirstState =
Diag.DiagStatesByLoc.FirstDiagState;
6584 DiagStates.push_back(FirstState);
6588 "Invalid data, unexpected backref in initial state");
6590 assert(Idx <
Record.size() &&
6591 "Invalid data, not enough state change pairs in initial state");
6596 unsigned Flags =
Record[Idx++];
6598 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
6599 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
6600 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
6601 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
6602 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
6604 FirstState = ReadDiagState(Initial,
true);
6612 .StateTransitions.push_back({FirstState, 0});
6617 FirstState = ReadDiagState(*
Diag.DiagStatesByLoc.CurDiagState,
false);
6621 unsigned NumLocations =
Record[Idx++];
6622 while (NumLocations--) {
6623 assert(Idx <
Record.size() &&
6624 "Invalid data, missing pragma diagnostic states");
6626 auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
6627 assert(IDAndOffset.first.isValid() &&
"invalid FileID for transition");
6628 assert(IDAndOffset.second == 0 &&
"not a start location for a FileID");
6629 unsigned Transitions =
Record[Idx++];
6635 auto &F =
Diag.DiagStatesByLoc.Files[IDAndOffset.first];
6636 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
6637 for (
unsigned I = 0; I != Transitions; ++I) {
6638 unsigned Offset =
Record[Idx++];
6639 auto *State = ReadDiagState(*FirstState,
false);
6640 F.StateTransitions.push_back({State, Offset});
6645 assert(Idx <
Record.size() &&
6646 "Invalid data, missing final pragma diagnostic state");
6648 auto *CurState = ReadDiagState(*FirstState,
false);
6651 Diag.DiagStatesByLoc.CurDiagState = CurState;
6652 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
6657 auto &T =
Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
6659 T.push_back({CurState, 0});
6661 T[0].State = CurState;
6670ASTReader::RecordLocation ASTReader::TypeCursorForIndex(
unsigned Index) {
6671 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
6672 assert(I != GlobalTypeMap.end() &&
"Corrupted global type map");
6674 return RecordLocation(
6681#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
6682 case TYPE_##CODE_ID: return Type::CLASS_ID;
6683#include "clang/Serialization/TypeBitCodes.def"
6685 return std::nullopt;
6695QualType ASTReader::readTypeRecord(
unsigned Index) {
6696 assert(ContextObj &&
"reading type with no AST context");
6698 RecordLocation Loc = TypeCursorForIndex(Index);
6699 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
6705 ReadingKindTracker ReadingKind(Read_Type, *
this);
6708 Deserializing AType(
this);
6710 if (llvm::Error Err = DeclsCursor.JumpToBit(Loc.Offset)) {
6711 Error(std::move(Err));
6716 Error(RawCode.takeError());
6723 Error(Code.takeError());
6734 Error(
"Unexpected code for type");
6739 return TypeReader.read(*maybeClass);
6767 : Reader(Reader),
Seq(
Seq) {}
6772#define ABSTRACT_TYPELOC(CLASS, PARENT)
6773#define TYPELOC(CLASS, PARENT) \
6774 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6775#include "clang/AST/TypeLocNodes.def"
6837 if (Reader.readBool())
6844 VisitArrayTypeLoc(TL);
6848 VisitArrayTypeLoc(TL);
6852 VisitArrayTypeLoc(TL);
6855void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6857 VisitArrayTypeLoc(TL);
6860void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6868void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6877void TypeLocReader::VisitDependentVectorTypeLoc(
6893void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
6907 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i) {
6913 VisitFunctionTypeLoc(TL);
6917 VisitFunctionTypeLoc(TL);
6924void TypeLocReader::VisitUsingTypeLoc(
UsingTypeLoc TL) {
6962 auto NNS = readNestedNameSpecifierLoc();
6963 auto TemplateKWLoc = readSourceLocation();
6964 auto ConceptNameLoc = readDeclarationNameInfo();
6965 auto FoundDecl = readDeclAs<NamedDecl>();
6966 auto NamedConcept = readDeclAs<ConceptDecl>();
6968 getContext(), NNS, TemplateKWLoc, ConceptNameLoc, FoundDecl, NamedConcept,
6969 (readBool() ? readASTTemplateArgumentListInfo() :
nullptr));
6973void TypeLocReader::VisitAutoTypeLoc(
AutoTypeLoc TL) {
6975 if (Reader.readBool())
6977 if (Reader.readBool())
6981void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6990void TypeLocReader::VisitEnumTypeLoc(
EnumTypeLoc TL) {
7006void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
7011void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
7016void TypeLocReader::VisitTemplateSpecializationTypeLoc(
7022 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
7024 Reader.readTemplateArgumentLocInfo(
7028void TypeLocReader::VisitParenTypeLoc(
ParenTypeLoc TL) {
7048void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
7056 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I)
7058 Reader.readTemplateArgumentLocInfo(
7102void TypeLocReader::VisitPipeTypeLoc(
PipeTypeLoc TL) {
7109void TypeLocReader::VisitDependentBitIntTypeLoc(
7126 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
7132 assert(ContextObj &&
"reading type with no AST context");
7143 llvm_unreachable(
"Invalid predefined type");
7329#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7330 case PREDEF_TYPE_##Id##_ID: \
7331 T = Context.SingletonId; \
7333#include "clang/Basic/OpenCLImageTypes.def"
7334#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7335 case PREDEF_TYPE_##Id##_ID: \
7336 T = Context.Id##Ty; \
7338#include "clang/Basic/OpenCLExtensionTypes.def"
7378#define SVE_TYPE(Name, Id, SingletonId) \
7379 case PREDEF_TYPE_##Id##_ID: \
7380 T = Context.SingletonId; \
7382#include "clang/Basic/AArch64SVEACLETypes.def"
7383#define PPC_VECTOR_TYPE(Name, Id, Size) \
7384 case PREDEF_TYPE_##Id##_ID: \
7385 T = Context.Id##Ty; \
7387#include "clang/Basic/PPCTypes.def"
7388#define RVV_TYPE(Name, Id, SingletonId) \
7389 case PREDEF_TYPE_##Id##_ID: \
7390 T = Context.SingletonId; \
7392#include "clang/Basic/RISCVVTypes.def"
7393#define WASM_TYPE(Name, Id, SingletonId) \
7394 case PREDEF_TYPE_##Id##_ID: \
7395 T = Context.SingletonId; \
7397#include "clang/Basic/WebAssemblyReferenceTypes.def"
7400 assert(!T.
isNull() &&
"Unknown predefined type");
7405 assert(Index < TypesLoaded.size() &&
"Type index out-of-range");
7406 if (TypesLoaded[Index].isNull()) {
7407 TypesLoaded[Index] = readTypeRecord(Index);
7408 if (TypesLoaded[Index].isNull())
7411 TypesLoaded[Index]->setFromAST();
7412 if (DeserializationListener)
7414 TypesLoaded[Index]);
7417 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7421 return GetType(getGlobalTypeID(F, LocalID));
7433 ReadModuleOffsetMap(F);
7437 assert(I != F.
TypeRemap.
end() &&
"Invalid index into type index remap");
7439 unsigned GlobalIndex = LocalIndex + I->second;
7449 return readTypeSourceInfo();
7452 readNestedNameSpecifierLoc();
7462 TemplateNameLoc, EllipsisLoc);
7473 llvm_unreachable(
"unexpected template argument loc");
7488 Result.setLAngleLoc(readSourceLocation());
7489 Result.setRAngleLoc(readSourceLocation());
7490 unsigned NumArgsAsWritten = readInt();
7491 for (
unsigned i = 0; i != NumArgsAsWritten; ++i)
7492 Result.addArgument(readTemplateArgumentLoc());
7498 readTemplateArgumentListInfo(
Result);
7507 if (NumCurrentElementsDeserializing) {
7512 PendingIncompleteDeclChains.push_back(
const_cast<Decl*
>(D));
7517 assert(isa<TranslationUnitDecl>(D) &&
"Not a TU?");
7528 if (isa<TranslationUnitDecl, NamespaceDecl, RecordDecl, EnumDecl>(DC)) {
7530 if (!getContext().getLangOpts().
CPlusPlus &&
7531 isa<TranslationUnitDecl>(DC)) {
7535 auto *II = Name.getAsIdentifierInfo();
7536 assert(II &&
"non-identifier name in C?");
7537 if (II->isOutOfDate())
7538 updateOutOfDateIdentifier(*II);
7544 auto *DC = cast<DeclContext>(DCDecl);
7546 FindExternalLexicalDecls(
7552 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7553 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7554 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7555 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7556 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
7557 if (
auto *Template = FD->getPrimaryTemplate())
7558 Template->LoadLazySpecializations();
7564 RecordLocation Loc = getLocalBitOffset(Offset);
7565 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7567 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7568 Error(std::move(Err));
7571 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7576 Error(MaybeCode.takeError());
7579 unsigned Code = MaybeCode.get();
7583 if (!MaybeRecCode) {
7584 Error(MaybeRecCode.takeError());
7588 Error(
"malformed AST file: missing C++ ctor initializers");
7592 return Record.readCXXCtorInitializers();
7596 assert(ContextObj &&
"reading base specifiers with no AST context");
7599 RecordLocation Loc = getLocalBitOffset(Offset);
7600 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7602 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7603 Error(std::move(Err));
7606 ReadingKindTracker ReadingKind(Read_Decl, *
this);
7611 Error(MaybeCode.takeError());
7614 unsigned Code = MaybeCode.get();
7618 if (!MaybeRecCode) {
7619 Error(MaybeCode.takeError());
7622 unsigned RecCode = MaybeRecCode.get();
7625 Error(
"malformed AST file: missing C++ base specifiers");
7629 unsigned NumBases =
Record.readInt();
7632 for (
unsigned I = 0; I != NumBases; ++I)
7633 Bases[I] =
Record.readCXXBaseSpecifier();
7643 ReadModuleOffsetMap(F);
7647 assert(I != F.
DeclRemap.
end() &&
"Invalid index into decl index remap");
7649 return LocalID + I->second;
7666 assert(I != GlobalDeclMap.end() &&
"Corrupted global declaration map");
7676 if (Index > DeclsLoaded.size()) {
7677 Error(
"declaration ID out-of-range for AST file");
7681 if (
Decl *D = DeclsLoaded[Index])
7682 return D->getLocation();
7685 DeclCursorForID(ID, Loc);
7745 llvm_unreachable(
"PredefinedDeclIDs unknown enum value");
7749 assert(ContextObj &&
"reading decl with no AST context");
7757 Merged.push_back(ID);
7764 if (Index >= DeclsLoaded.size()) {
7765 assert(0 &&
"declaration ID out-of-range for AST file");
7766 Error(
"declaration ID out-of-range for AST file");
7770 return DeclsLoaded[Index];
7775 return GetExistingDecl(ID);
7779 if (Index >= DeclsLoaded.size()) {
7780 assert(0 &&
"declaration ID out-of-range for AST file");
7781 Error(
"declaration ID out-of-range for AST file");
7785 if (!DeclsLoaded[Index]) {
7787 if (DeserializationListener)
7788 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7791 return DeclsLoaded[Index];
7800 assert(I != GlobalDeclMap.end() &&
"Corrupted global declaration map");
7803 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7808 return GlobalID - Owner->
BaseDeclID + Pos->second;
7814 if (Idx >=
Record.size()) {
7815 Error(
"Corrupted AST file");
7819 return getGlobalDeclID(F,
Record[Idx++]);
7829 ClearSwitchCaseIDs();
7832 RecordLocation Loc = getLocalBitOffset(Offset);
7833 if (llvm::Error Err = Loc.F->DeclsCursor.JumpToBit(Loc.Offset)) {
7834 Error(std::move(Err));
7837 assert(NumCurrentElementsDeserializing == 0 &&
7838 "should not be called while already deserializing");
7840 return ReadStmtFromStream(*Loc.F);
7849 assert(LexicalDecls.size() % 2 == 0 &&
"expected an even number of entries");
7850 for (
int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7852 if (!IsKindWeWant(K))
7860 if (PredefsVisited[ID])
7863 PredefsVisited[ID] =
true;
7866 if (
Decl *D = GetLocalDecl(*M, ID)) {
7867 assert(D->getKind() == K &&
"wrong kind for lexical decl");
7874 if (isa<TranslationUnitDecl>(DC)) {
7875 for (
const auto &Lexical : TULexicalDecls)
7876 Visit(Lexical.first, Lexical.second);
7878 auto I = LexicalDecls.find(DC);
7879 if (I != LexicalDecls.end())
7880 Visit(I->second.first, I->second.second);
7883 ++NumLexicalDeclContextsRead;
7920 unsigned Offset,
unsigned Length,
7924 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(
File);
7925 if (I == FileDeclIDs.end())
7928 FileDeclsInfo &DInfo = I->second;
7929 if (DInfo.Decls.empty())
7933 BeginLoc =
SM.getLocForStartOfFile(
File).getLocWithOffset(Offset);
7936 DeclIDComp DIDComp(*
this, *DInfo.Mod);
7938 llvm::lower_bound(DInfo.Decls, BeginLoc, DIDComp);
7939 if (BeginIt != DInfo.Decls.begin())
7945 while (BeginIt != DInfo.Decls.begin() &&
7946 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7947 ->isTopLevelDeclInObjCContainer())
7951 llvm::upper_bound(DInfo.Decls, EndLoc, DIDComp);
7952 if (EndIt != DInfo.Decls.end())
7956 DIt = BeginIt; DIt != EndIt; ++DIt)
7957 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7964 "DeclContext has no visible decls in storage");
7968 auto It = Lookups.find(DC);
7969 if (It == Lookups.end())
7977 for (
DeclID ID : It->second.Table.find(Name)) {
7978 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7979 if (ND->
getDeclName() == Name && Found.insert(ND).second)
7980 Decls.push_back(ND);
7983 ++NumVisibleDeclContextsRead;
7984 SetExternalVisibleDeclsForName(DC, Name, Decls);
7985 return !Decls.empty();
7992 auto It = Lookups.find(DC);
7993 assert(It != Lookups.end() &&
7994 "have external visible storage but no lookup tables");
7998 for (
DeclID ID : It->second.Table.findAll()) {
7999 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
8003 ++NumVisibleDeclContextsRead;
8005 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
8006 SetExternalVisibleDeclsForName(DC, I->first, I->second);
8008 const_cast<DeclContext *
>(DC)->setHasExternalVisibleStorage(
false);
8013 auto I = Lookups.find(Primary);
8014 return I == Lookups.end() ? nullptr : &I->second;
8023 assert(ImplD && Consumer);
8025 for (
auto *I : ImplD->
methods())
8031void ASTReader::PassInterestingDeclToConsumer(
Decl *D) {
8039 this->Consumer = Consumer;
8042 PassInterestingDeclsToConsumer();
8044 if (DeserializationListener)
8045 DeserializationListener->ReaderInitialized(
this);
8049 std::fprintf(stderr,
"*** AST File Statistics:\n");
8051 unsigned NumTypesLoaded =
8052 TypesLoaded.size() - llvm::count(TypesLoaded.materialized(),
QualType());
8053 unsigned NumDeclsLoaded =
8054 DeclsLoaded.size() -
8055 llvm::count(DeclsLoaded.materialized(), (
Decl *)
nullptr);
8056 unsigned NumIdentifiersLoaded =
8057 IdentifiersLoaded.size() -
8059 unsigned NumMacrosLoaded =
8060 MacrosLoaded.size() - llvm::count(MacrosLoaded, (
MacroInfo *)
nullptr);
8061 unsigned NumSelectorsLoaded =
8062 SelectorsLoaded.size() - llvm::count(SelectorsLoaded,
Selector());
8064 if (
unsigned TotalNumSLocEntries = getTotalNumSLocs())
8065 std::fprintf(stderr,
" %u/%u source location entries read (%f%%)\n",
8066 NumSLocEntriesRead, TotalNumSLocEntries,
8067 ((
float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
8068 if (!TypesLoaded.empty())
8069 std::fprintf(stderr,
" %u/%u types read (%f%%)\n",
8070 NumTypesLoaded, (
unsigned)TypesLoaded.size(),
8071 ((
float)NumTypesLoaded/TypesLoaded.size() * 100));
8072 if (!DeclsLoaded.empty())
8073 std::fprintf(stderr,
" %u/%u declarations read (%f%%)\n",
8074 NumDeclsLoaded, (
unsigned)DeclsLoaded.size(),
8075 ((
float)NumDeclsLoaded/DeclsLoaded.size() * 100));
8076 if (!IdentifiersLoaded.empty())
8077 std::fprintf(stderr,
" %u/%u identifiers read (%f%%)\n",
8078 NumIdentifiersLoaded, (
unsigned)IdentifiersLoaded.size(),
8079 ((
float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
8080 if (!MacrosLoaded.empty())
8081 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8082 NumMacrosLoaded, (
unsigned)MacrosLoaded.size(),
8083 ((
float)NumMacrosLoaded/MacrosLoaded.size() * 100));
8084 if (!SelectorsLoaded.empty())
8085 std::fprintf(stderr,
" %u/%u selectors read (%f%%)\n",
8086 NumSelectorsLoaded, (
unsigned)SelectorsLoaded.size(),
8087 ((
float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
8088 if (TotalNumStatements)
8089 std::fprintf(stderr,
" %u/%u statements read (%f%%)\n",
8090 NumStatementsRead, TotalNumStatements,
8091 ((
float)NumStatementsRead/TotalNumStatements * 100));
8093 std::fprintf(stderr,
" %u/%u macros read (%f%%)\n",
8094 NumMacrosRead, TotalNumMacros,
8095 ((
float)NumMacrosRead/TotalNumMacros * 100));
8096 if (TotalLexicalDeclContexts)
8097 std::fprintf(stderr,
" %u/%u lexical declcontexts read (%f%%)\n",
8098 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
8099 ((
float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
8101 if (TotalVisibleDeclContexts)
8102 std::fprintf(stderr,
" %u/%u visible declcontexts read (%f%%)\n",
8103 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
8104 ((
float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
8106 if (TotalNumMethodPoolEntries)
8107 std::fprintf(stderr,
" %u/%u method pool entries read (%f%%)\n",
8108 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
8109 ((
float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
8111 if (NumMethodPoolLookups)
8112 std::fprintf(stderr,
" %u/%u method pool lookups succeeded (%f%%)\n",
8113 NumMethodPoolHits, NumMethodPoolLookups,
8114 ((
float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
8115 if (NumMethodPoolTableLookups)
8116 std::fprintf(stderr,
" %u/%u method pool table lookups succeeded (%f%%)\n",
8117 NumMethodPoolTableHits, NumMethodPoolTableLookups,
8118 ((
float)NumMethodPoolTableHits/NumMethodPoolTableLookups
8120 if (NumIdentifierLookupHits)
8121 std::fprintf(stderr,
8122 " %u / %u identifier table lookups succeeded (%f%%)\n",
8123 NumIdentifierLookupHits, NumIdentifierLookups,
8124 (
double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
8127 std::fprintf(stderr,
"\n");
8128 GlobalIndex->printStats();
8131 std::fprintf(stderr,
"\n");
8133 std::fprintf(stderr,
"\n");
8136template<
typename Key,
typename ModuleFile,
unsigned InitialCapacity>
8137LLVM_DUMP_METHOD
static void
8140 InitialCapacity> &Map) {
8141 if (Map.begin() == Map.end())
8146 llvm::errs() << Name <<
":\n";
8147 for (
typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
8149 llvm::errs() <<
" " << I->first <<
" -> " << I->second->FileName
8155 llvm::errs() <<
"*** PCH/ModuleFile Remappings:\n";
8157 dumpModuleIDMap(
"Global source location entry map", GlobalSLocEntryMap);
8165 GlobalPreprocessedEntityMap);
8167 llvm::errs() <<
"\n*** PCH/Modules Loaded:";
8176 if (llvm::MemoryBuffer *buf = I.Buffer) {
8177 size_t bytes = buf->getBufferSize();
8178 switch (buf->getBufferKind()) {
8179 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
8182 case llvm::MemoryBuffer::MemoryBuffer_MMap:
8196 for (uint64_t ID : PreloadedDeclIDs) {
8197 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
8200 PreloadedDeclIDs.clear();
8203 if (!FPPragmaOptions.empty()) {
8204 assert(FPPragmaOptions.size() == 1 &&
"Wrong number of FP_PRAGMA_OPTIONS");
8207 SemaObj->CurFPFeatures =
8211 SemaObj->OpenCLFeatures = OpenCLExtensions;
8217 assert(SemaObj &&
"no Sema to update");
8221 if (!SemaDeclRefs.empty()) {
8222 assert(SemaDeclRefs.size() % 3 == 0);
8223 for (
unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
8224 if (!SemaObj->StdNamespace)
8225 SemaObj->StdNamespace = SemaDeclRefs[I];
8226 if (!SemaObj->StdBadAlloc)
8227 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
8228 if (!SemaObj->StdAlignValT)
8229 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
8231 SemaDeclRefs.clear();
8236 if(OptimizeOffPragmaLocation.isValid())
8237 SemaObj->ActOnPragmaOptimize(
false, OptimizeOffPragmaLocation);
8238 if (PragmaMSStructState != -1)
8240 if (PointersToMembersPragmaLocation.isValid()) {
8241 SemaObj->ActOnPragmaMSPointersToMembers(
8243 PragmaMSPointersToMembersState,
8244 PointersToMembersPragmaLocation);
8246 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
8248 if (PragmaAlignPackCurrentValue) {
8252 bool DropFirst =
false;
8253 if (!PragmaAlignPackStack.empty() &&
8254 PragmaAlignPackStack.front().Location.isInvalid()) {
8255 assert(PragmaAlignPackStack.front().Value ==
8256 SemaObj->AlignPackStack.DefaultValue &&
8257 "Expected a default alignment value");
8258 SemaObj->AlignPackStack.Stack.emplace_back(
8259 PragmaAlignPackStack.front().SlotLabel,
8260 SemaObj->AlignPackStack.CurrentValue,
8261 SemaObj->AlignPackStack.CurrentPragmaLocation,
8262 PragmaAlignPackStack.front().PushLocation);
8265 for (
const auto &Entry :
8266 llvm::ArrayRef(PragmaAlignPackStack).drop_front(DropFirst ? 1 : 0)) {
8267 SemaObj->AlignPackStack.Stack.emplace_back(
8268 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8270 if (PragmaAlignPackCurrentLocation.isInvalid()) {
8271 assert(*PragmaAlignPackCurrentValue ==
8272 SemaObj->AlignPackStack.DefaultValue &&
8273 "Expected a default align and pack value");
8276 SemaObj->AlignPackStack.CurrentValue = *PragmaAlignPackCurrentValue;
8277 SemaObj->AlignPackStack.CurrentPragmaLocation =
8278 PragmaAlignPackCurrentLocation;
8281 if (FpPragmaCurrentValue) {
8285 bool DropFirst =
false;
8286 if (!FpPragmaStack.empty() && FpPragmaStack.front().Location.isInvalid()) {
8287 assert(FpPragmaStack.front().Value ==
8288 SemaObj->FpPragmaStack.DefaultValue &&
8289 "Expected a default pragma float_control value");
8290 SemaObj->FpPragmaStack.Stack.emplace_back(
8291 FpPragmaStack.front().SlotLabel, SemaObj->FpPragmaStack.CurrentValue,
8292 SemaObj->FpPragmaStack.CurrentPragmaLocation,
8293 FpPragmaStack.front().PushLocation);
8296 for (
const auto &Entry :
8298 SemaObj->FpPragmaStack.Stack.emplace_back(
8299 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
8300 if (FpPragmaCurrentLocation.isInvalid()) {
8301 assert(*FpPragmaCurrentValue == SemaObj->FpPragmaStack.DefaultValue &&
8302 "Expected a default pragma float_control value");
8305 SemaObj->FpPragmaStack.CurrentValue = *FpPragmaCurrentValue;
8306 SemaObj->FpPragmaStack.CurrentPragmaLocation = FpPragmaCurrentLocation;
8311 for (
auto &Import : PendingImportedModulesSema) {
8312 if (Import.ImportLoc.isInvalid())
8314 if (
Module *Imported = getSubmodule(Import.ID)) {
8315 SemaObj->makeModuleVisible(Imported, Import.ImportLoc);
8318 PendingImportedModulesSema.clear();
8325 IdentifierLookupVisitor Visitor(Name, 0,
8326 NumIdentifierLookups,
8327 NumIdentifierLookupHits);
8333 if (PP.getLangOpts().CPlusPlus) {
8334 for (
auto *F : ModuleMgr.pch_modules())
8342 if (!loadGlobalIndex()) {
8343 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
8348 ModuleMgr.visit(Visitor, HitsPtr);
8352 markIdentifierUpToDate(II);
8370 ASTIdentifierLookupTable::key_iterator Current;
8374 ASTIdentifierLookupTable::key_iterator End;
8381 bool SkipModules =
false);
8383 StringRef Next()
override;
8390 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8394 while (Current == End) {
8406 Current = IdTable->key_begin();
8407 End = IdTable->key_end();
8412 StringRef
Result = *Current;
8421 std::unique_ptr<IdentifierIterator> Current;
8422 std::unique_ptr<IdentifierIterator> Queued;
8425 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator>
First,
8426 std::unique_ptr<IdentifierIterator> Second)
8427 : Current(
std::move(
First)), Queued(
std::move(Second)) {}
8429 StringRef Next()
override {
8433 StringRef result = Current->Next();
8434 if (!result.empty())
8439 std::swap(Current, Queued);
8448 std::unique_ptr<IdentifierIterator> ReaderIter(
8450 std::unique_ptr<IdentifierIterator> ModulesIter(
8451 GlobalIndex->createIdentifierIterator());
8452 return new ChainedIdentifierIterator(std::move(ReaderIter),
8453 std::move(ModulesIter));
8460namespace serialization {
8465 unsigned PriorGeneration;
8466 unsigned InstanceBits = 0;
8467 unsigned FactoryBits = 0;
8468 bool InstanceHasMoreThanOneDecl =
false;
8469 bool FactoryHasMoreThanOneDecl =
false;
8475 unsigned PriorGeneration)
8476 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8486 ++Reader.NumMethodPoolTableLookups;
8489 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8490 if (Pos == PoolTable->end())
8493 ++Reader.NumMethodPoolTableHits;
8494 ++Reader.NumSelectorsRead;
8498 ++Reader.NumMethodPoolEntriesRead;
8500 if (Reader.DeserializationListener)
8506 InstanceMethods.append(
Data.Instance.rbegin(),
Data.Instance.rend());
8507 FactoryMethods.append(
Data.Factory.rbegin(),
Data.Factory.rend());
8508 InstanceBits =
Data.InstanceBits;
8509 FactoryBits =
Data.FactoryBits;
8510 InstanceHasMoreThanOneDecl =
Data.InstanceHasMoreThanOneDecl;
8511 FactoryHasMoreThanOneDecl =
Data.FactoryHasMoreThanOneDecl;
8517 return InstanceMethods;
8522 return FactoryMethods;
8529 return InstanceHasMoreThanOneDecl;
8547 unsigned &Generation = SelectorGeneration[Sel];
8548 unsigned PriorGeneration = Generation;
8550 SelectorOutOfDate[Sel] =
false;
8553 ++NumMethodPoolLookups;
8555 ModuleMgr.
visit(Visitor);
8561 ++NumMethodPoolHits;
8584 if (SelectorOutOfDate[Sel])
8592 for (
unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8594 = dyn_cast_or_null<NamespaceDecl>(
GetDecl(KnownNamespaces[I])))
8595 Namespaces.push_back(Namespace);
8600 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8601 for (
unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8605 Undefined.insert(std::make_pair(D, Loc));
8612 for (
unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8614 uint64_t Count = DelayedDeleteExprs[Idx++];
8615 for (uint64_t
C = 0;
C < Count; ++
C) {
8618 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8619 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8626 for (
unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8627 VarDecl *Var = dyn_cast_or_null<VarDecl>(
GetDecl(TentativeDefinitions[I]));
8629 TentativeDefs.push_back(Var);
8631 TentativeDefinitions.clear();
8636 for (
unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8638 = dyn_cast_or_null<DeclaratorDecl>(
GetDecl(UnusedFileScopedDecls[I]));
8642 UnusedFileScopedDecls.clear();
8647 for (
unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8649 = dyn_cast_or_null<CXXConstructorDecl>(
GetDecl(DelegatingCtorDecls[I]));
8653 DelegatingCtorDecls.clear();
8657 for (
unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8659 = dyn_cast_or_null<TypedefNameDecl>(
GetDecl(ExtVectorDecls[I]));
8663 ExtVectorDecls.clear();
8668 for (
unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8671 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8675 UnusedLocalTypedefNameCandidates.clear();
8680 for (
auto I : DeclsToCheckForDeferredDiags) {
8681 auto *D = dyn_cast_or_null<Decl>(
GetDecl(I));
8685 DeclsToCheckForDeferredDiags.clear();
8690 if (ReferencedSelectorsData.empty())
8695 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8697 while (I < DataSize) {
8701 Sels.push_back(std::make_pair(Sel, SelLoc));
8703 ReferencedSelectorsData.clear();
8708 if (WeakUndeclaredIdentifiers.empty())
8711 for (
unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; ) {
8719 WeakIDs.push_back(std::make_pair(WeakId, WI));
8721 WeakUndeclaredIdentifiers.clear();
8725 for (
unsigned Idx = 0, N = VTableUses.size(); Idx < N; ) {
8727 VT.
Record = dyn_cast_or_null<CXXRecordDecl>(
GetDecl(VTableUses[Idx++]));
8730 VTables.push_back(VT);
8738 for (
unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8743 Pending.push_back(std::make_pair(D, Loc));
8745 PendingInstantiations.clear();
8749 llvm::MapVector<
const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8751 for (
auto &LPT : LateParsedTemplates) {
8754 for (
unsigned Idx = 0, N = LateParsed.size(); Idx < N;
8757 cast<FunctionDecl>(
GetLocalDecl(*FMod, LateParsed[Idx++]));
8759 auto LT = std::make_unique<LateParsedTemplate>();
8764 assert(F &&
"No module");
8766 unsigned TokN = LateParsed[Idx++];
8767 LT->Toks.reserve(TokN);
8768 for (
unsigned T = 0; T < TokN; ++T)
8769 LT->Toks.push_back(
ReadToken(*F, LateParsed, Idx));
8771 LPTMap.insert(std::make_pair(FD, std::move(
LT)));
8775 LateParsedTemplates.clear();
8782 LambdaDeclarationsForMerging.insert(
8795 assert(ID &&
"Non-zero identifier ID required");
8796 assert(ID <= IdentifiersLoaded.size() &&
"identifier ID out of range");
8797 IdentifiersLoaded[ID - 1] = II;
8798 if (DeserializationListener)
8822 if (NumCurrentElementsDeserializing && !Decls) {
8823 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8827 for (
unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8840 Decls->push_back(D);
8847 pushExternalDeclIntoScope(D, II);
8855 if (IdentifiersLoaded.empty()) {
8856 Error(
"no identifier table in AST file");
8861 if (!IdentifiersLoaded[ID]) {
8863 assert(I != GlobalIdentifierMap.
end() &&
"Corrupted global identifier map");
8866 const unsigned char *
Data =
8873 IdentifiersLoaded[ID] = &II;
8875 if (DeserializationListener)
8879 return IdentifiersLoaded[ID];
8891 ReadModuleOffsetMap(M);
8896 &&
"Invalid index into identifier index remap");
8898 return LocalID + I->second;
8905 if (MacrosLoaded.empty()) {
8906 Error(
"no macro table in AST file");
8911 if (!MacrosLoaded[ID]) {
8914 assert(I != GlobalMacroMap.
end() &&
"Corrupted global macro map");
8920 if (DeserializationListener)
8925 return MacrosLoaded[ID];
8933 ReadModuleOffsetMap(M);
8937 assert(I != M.
MacroRemap.
end() &&
"Invalid index into macro index remap");
8939 return LocalID + I->second;
8948 ReadModuleOffsetMap(M);
8953 &&
"Invalid index into submodule index remap");
8955 return LocalID + I->second;
8960 assert(GlobalID == 0 &&
"Unhandled global submodule ID");
8964 if (GlobalID > SubmodulesLoaded.size()) {
8965 Error(
"submodule ID out of range in AST file");
8980 return I == GlobalSubmoduleMap.
end() ? nullptr : I->second;
8983 unsigned IndexFromEnd = ID >> 1;
8984 assert(IndexFromEnd &&
"got reference to unknown module file");
9001 auto I = llvm::find(PCHModules, M);
9002 assert(I != PCHModules.end() &&
"emitting reference to unknown file");
9003 return (I - PCHModules.end()) << 1;
9013 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
9018 llvm::sys::path::parent_path(MF.
FileName),
9021 return std::nullopt;
9025 auto I = DefinitionSource.find(FD);
9026 if (I == DefinitionSource.end())
9039 if (ID > SelectorsLoaded.size()) {
9040 Error(
"selector ID out of range in AST file");
9044 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() ==
nullptr) {
9047 assert(I != GlobalSelectorMap.
end() &&
"Corrupted global selector map");
9051 SelectorsLoaded[ID - 1] =
9053 if (DeserializationListener)
9054 DeserializationListener->
SelectorRead(ID, SelectorsLoaded[ID - 1]);
9057 return SelectorsLoaded[ID - 1];
9075 ReadModuleOffsetMap(M);
9080 &&
"Invalid index into selector index remap");
9082 return LocalID + I->second;
9087 switch (Name.getNameKind()) {
9113 NameInfo.
setName(readDeclarationName());
9121 unsigned NumTPLists =
readInt();
9126 for (
unsigned i = 0; i != NumTPLists; ++i)
9137 unsigned NumParams =
readInt();
9139 Params.reserve(NumParams);
9141 Params.push_back(readDeclAs<NamedDecl>());
9143 bool HasRequiresClause =
readBool();
9144 Expr *RequiresClause = HasRequiresClause ?
readExpr() :
nullptr;
9147 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
9148 return TemplateParams;
9153 bool Canonicalize) {
9154 unsigned NumTemplateArgs =
readInt();
9155 TemplArgs.reserve(NumTemplateArgs);
9156 while (NumTemplateArgs--)
9162 unsigned NumDecls =
readInt();
9164 while (NumDecls--) {
9176 bool inheritConstructors =
readBool();
9182 Result.setInheritConstructors(inheritConstructors);
9189 unsigned NumInitializers =
readInt();
9190 assert(NumInitializers &&
"wrote ctor initializers but have no inits");
9192 for (
unsigned i = 0; i != NumInitializers; ++i) {
9194 bool IsBaseVirtual =
false;
9210 Member = readDeclAs<FieldDecl>();
9214 IndirectMember = readDeclAs<IndirectFieldDecl>();
9225 BOMInit =
new (Context)
9227 RParenLoc, MemberOrEllipsisLoc);
9229 BOMInit =
new (Context)
9232 BOMInit =
new (Context)
9236 BOMInit =
new (Context)
9238 LParenLoc,
Init, RParenLoc);
9241 unsigned SourceOrder =
readInt();
9245 CtorInitializers[i] = BOMInit;
9248 return CtorInitializers;
9256 for (
unsigned I = 0; I != N; ++I) {
9257 auto Kind = readNestedNameSpecifierKind();
9262 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9269 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9276 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9289 Builder.Extend(Context,
9297 Builder.MakeGlobal(Context, ColonColonLoc);
9304 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9310 return Builder.getWithLocInContext(Context);
9321 const StringRef Blob) {
9322 unsigned Count =
Record[0];
9323 const char *Byte = Blob.data();
9324 llvm::BitVector Ret = llvm::BitVector(Count,
false);
9325 for (
unsigned I = 0; I < Count; ++Byte)
9326 for (
unsigned Bit = 0; Bit < 8 && I < Count; ++Bit, ++I)
9327 if (*Byte & (1 << Bit))
9339 unsigned Len =
Record[Idx++];
9355 if (!BaseDirectory.empty())
9362 unsigned Major =
Record[Idx++];
9363 unsigned Minor =
Record[Idx++];
9364 unsigned Subminor =
Record[Idx++];
9366 return VersionTuple(Major);
9368 return VersionTuple(Major, Minor - 1);
9369 return VersionTuple(Major, Minor - 1, Subminor - 1);
9380 return Diag(CurrentImportLoc, DiagID);
9384 return Diags.
Report(Loc, DiagID);
9396 assert((*CurrSwitchCaseStmts)[ID] ==
nullptr &&
9397 "Already have a SwitchCase with this ID");
9398 (*CurrSwitchCaseStmts)[ID] = SC;
9403 assert((*CurrSwitchCaseStmts)[ID] !=
nullptr &&
"No SwitchCase with this ID");
9404 return (*CurrSwitchCaseStmts)[ID];
9408 CurrSwitchCaseStmts->clear();
9413 std::vector<RawComment *> Comments;
9420 BitstreamCursor &Cursor = I->first;
9427 Cursor.advanceSkippingSubblocks(
9428 BitstreamCursor::AF_DontPopBlockAtEnd);
9430 Error(MaybeEntry.takeError());
9433 llvm::BitstreamEntry Entry = MaybeEntry.get();
9435 switch (Entry.Kind) {
9436 case llvm::BitstreamEntry::SubBlock:
9437 case llvm::BitstreamEntry::Error:
9438 Error(
"malformed block record in AST file");
9440 case llvm::BitstreamEntry::EndBlock:
9442 case llvm::BitstreamEntry::Record:
9450 if (!MaybeComment) {
9451 Error(MaybeComment.takeError());
9460 bool IsTrailingComment =
Record[Idx++];
9461 bool IsAlmostTrailingComment =
Record[Idx++];
9463 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9469 llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
9470 FileToOffsetToComment;
9474 std::pair<FileID, unsigned> Loc =
9476 if (Loc.first.isValid())
9477 Context.
Comments.OrderedComments[Loc.first].emplace(Loc.second,
C);
9490 assert(NumUserInputs <= NumInputs);
9491 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9492 for (
unsigned I = 0; I < N; ++I) {
9493 bool IsSystem = I >= NumUserInputs;
9495 Visitor(IFI, IsSystem);
9500 bool IncludeSystem,
bool Complain,
9502 bool isSystem)> Visitor) {
9505 assert(NumUserInputs <= NumInputs);
9506 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9507 for (
unsigned I = 0; I < N; ++I) {
9508 bool IsSystem = I >= NumUserInputs;
9509 InputFile IF = getInputFile(MF, I+1, Complain);
9510 Visitor(IF, IsSystem);
9518 for (
unsigned I = 0; I < NumInputs; ++I) {
9521 if (
auto FE = getInputFile(MF, I + 1).getFile())
9526void ASTReader::finishPendingActions() {
9528 !PendingIdentifierInfos.empty() || !PendingDeducedFunctionTypes.empty() ||
9529 !PendingDeducedVarTypes.empty() || !PendingIncompleteDeclChains.empty() ||
9530 !PendingDeclChains.empty() || !PendingMacroIDs.empty() ||
9531 !PendingDeclContextInfos.empty() || !PendingUpdateRecords.empty() ||
9532 !PendingObjCExtensionIvarRedeclarations.empty()) {
9535 using TopLevelDeclsMap =
9536 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9537 TopLevelDeclsMap TopLevelDecls;
9539 while (!PendingIdentifierInfos.empty()) {
9542 std::move(PendingIdentifierInfos.back().second);
9543 PendingIdentifierInfos.pop_back();
9550 for (
unsigned I = 0; I != PendingDeducedFunctionTypes.size(); ++I) {
9551 auto *FD = PendingDeducedFunctionTypes[I].first;
9552 FD->setType(
GetType(PendingDeducedFunctionTypes[I].second));
9554 if (
auto *DT = FD->getReturnType()->getContainedDeducedType()) {
9557 if (DT->isDeduced()) {
9558 PendingDeducedTypeUpdates.insert(
9559 {FD->getCanonicalDecl(), FD->getReturnType()});
9566 PendingUndeducedFunctionDecls.push_back(FD);
9570 PendingDeducedFunctionTypes.clear();
9574 for (
unsigned I = 0; I != PendingDeducedVarTypes.size(); ++I) {
9575 auto *VD = PendingDeducedVarTypes[I].first;
9576 VD->setType(
GetType(PendingDeducedVarTypes[I].second));
9578 PendingDeducedVarTypes.clear();
9582 for (
unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9583 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9585 PendingIncompleteDeclChains.clear();
9588 for (
unsigned I = 0; I != PendingDeclChains.size(); ++I)
9589 loadPendingDeclChain(PendingDeclChains[I].first,
9590 PendingDeclChains[I].second);
9591 PendingDeclChains.clear();
9594 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9595 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9597 for (
unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9598 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9603 for (
unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9606 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9608 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9610 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9611 if (!Info.M->isModule())
9615 for (
unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9617 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9618 if (Info.M->isModule())
9622 PendingMacroIDs.clear();
9626 while (!PendingDeclContextInfos.empty()) {
9627 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9628 PendingDeclContextInfos.pop_front();
9631 Info.D->setDeclContextsImpl(SemaDC, LexicalDC,
getContext());
9635 while (!PendingUpdateRecords.empty()) {
9636 auto Update = PendingUpdateRecords.pop_back_val();
9637 ReadingKindTracker ReadingKind(Read_Decl, *
this);
9638 loadDeclUpdateRecords(
Update);
9641 while (!PendingObjCExtensionIvarRedeclarations.empty()) {
9642 auto ExtensionsPair = PendingObjCExtensionIvarRedeclarations.back().first;
9643 auto DuplicateIvars =
9644 PendingObjCExtensionIvarRedeclarations.back().second;
9647 ExtensionsPair.first->getASTContext(),
9648 ExtensionsPair.second->getASTContext(), NonEquivalentDecls,
9652 if (Ctx.IsEquivalent(ExtensionsPair.first, ExtensionsPair.second)) {
9654 for (
auto IvarPair : DuplicateIvars) {
9655 ObjCIvarDecl *Ivar = IvarPair.first, *PrevIvar = IvarPair.second;
9657 Ivar->setDeclContextsImpl(PrevIvar->getDeclContext(),
9663 ExtensionsPair.first->setInvalidDecl();
9664 ExtensionsPair.second->getClassInterface()
9666 ->setIvarList(
nullptr);
9668 for (
auto IvarPair : DuplicateIvars) {
9669 Diag(IvarPair.first->getLocation(),
9670 diag::err_duplicate_ivar_declaration)
9671 << IvarPair.first->getIdentifier();
9672 Diag(IvarPair.second->getLocation(), diag::note_previous_definition);
9675 PendingObjCExtensionIvarRedeclarations.pop_back();
9681 assert(PendingFakeDefinitionData.empty() &&
9682 "faked up a class definition but never saw the real one");
9688 for (
Decl *D : PendingDefinitions) {
9689 if (
TagDecl *TD = dyn_cast<TagDecl>(D)) {
9690 if (
const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9695 if (
auto RD = dyn_cast<CXXRecordDecl>(D)) {
9696 for (
auto *R = getMostRecentExistingDecl(RD); R;
9699 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9700 "declaration thinks it's the definition but it isn't");
9701 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9708 if (
auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9713 for (
auto *R = getMostRecentExistingDecl(ID); R; R = R->
getPreviousDecl())
9714 cast<ObjCInterfaceDecl>(R)->Data =
ID->Data;
9719 if (
auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9720 for (
auto *R = getMostRecentExistingDecl(PD); R; R = R->
getPreviousDecl())
9721 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9726 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9727 for (
auto *R = getMostRecentExistingDecl(RTD); R; R = R->
getPreviousDecl())
9728 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9730 PendingDefinitions.clear();
9736 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9737 PBEnd = PendingBodies.end();
9738 PB != PBEnd; ++PB) {
9739 if (
FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9749 if (
auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9750 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9755 if (!
getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9761 if (!FD->isLateTemplateParsed() &&
9762 !NonConstDefn->isLateTemplateParsed() &&
9765 !FD->shouldSkipCheckingODR() &&
9766 FD->getODRHash() != NonConstDefn->getODRHash()) {
9767 if (!isa<CXXMethodDecl>(FD)) {
9768 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9769 }
else if (FD->getLexicalParent()->isFileContext() &&
9770 NonConstDefn->getLexicalParent()->isFileContext()) {
9774 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9785 PendingBodies.clear();
9788 for (
auto [RD, MD] : PendingAddedClassMembers) {
9789 RD->addedMember(MD);
9791 PendingAddedClassMembers.clear();
9794 for (
auto *ND : PendingMergedDefinitionsToDeduplicate)
9796 PendingMergedDefinitionsToDeduplicate.clear();
9799void ASTReader::diagnoseOdrViolations() {
9800 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9801 PendingRecordOdrMergeFailures.empty() &&
9802 PendingFunctionOdrMergeFailures.empty() &&
9803 PendingEnumOdrMergeFailures.empty() &&
9804 PendingObjCInterfaceOdrMergeFailures.empty() &&
9805 PendingObjCProtocolOdrMergeFailures.empty())
9812 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9813 PendingOdrMergeFailures.clear();
9814 for (
auto &Merge : OdrMergeFailures) {
9815 Merge.first->buildLookup();
9816 Merge.first->decls_begin();
9817 Merge.first->bases_begin();
9818 Merge.first->vbases_begin();
9819 for (
auto &RecordPair : Merge.second) {
9820 auto *RD = RecordPair.first;
9828 auto RecordOdrMergeFailures = std::move(PendingRecordOdrMergeFailures);
9829 PendingRecordOdrMergeFailures.clear();
9830 for (
auto &Merge : RecordOdrMergeFailures) {
9831 Merge.first->decls_begin();
9832 for (
auto &D : Merge.second)
9837 auto ObjCInterfaceOdrMergeFailures =
9838 std::move(PendingObjCInterfaceOdrMergeFailures);
9839 PendingObjCInterfaceOdrMergeFailures.clear();
9840 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
9841 Merge.first->decls_begin();
9842 for (
auto &InterfacePair : Merge.second)
9843 InterfacePair.first->decls_begin();
9847 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9848 PendingFunctionOdrMergeFailures.clear();
9849 for (
auto &Merge : FunctionOdrMergeFailures) {
9850 Merge.first->buildLookup();
9851 Merge.first->decls_begin();
9852 Merge.first->getBody();
9853 for (
auto &FD : Merge.second) {
9861 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9862 PendingEnumOdrMergeFailures.clear();
9863 for (
auto &Merge : EnumOdrMergeFailures) {
9864 Merge.first->decls_begin();
9865 for (
auto &
Enum : Merge.second) {
9866 Enum->decls_begin();
9871 auto ObjCProtocolOdrMergeFailures =
9872 std::move(PendingObjCProtocolOdrMergeFailures);
9873 PendingObjCProtocolOdrMergeFailures.clear();
9874 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
9875 Merge.first->decls_begin();
9876 for (
auto &ProtocolPair : Merge.second)
9877 ProtocolPair.first->decls_begin();
9886 while (!PendingOdrMergeChecks.empty()) {
9887 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9901 for (
auto *RI : D->
redecls()) {
9902 if (RI->getLexicalDeclContext() == CanonDef) {
9917 for (
auto *CanonMember : CanonDef->
decls()) {
9918 if (CanonMember->getCanonicalDecl() == DCanon) {
9927 if (
auto *ND = dyn_cast<NamedDecl>(CanonMember))
9929 Candidates.push_back(ND);
9935 if (!isa<TagDecl>(D))
9940 Deserializing RecursionGuard(
this);
9942 std::string CanonDefModule =
9944 cast<Decl>(CanonDef));
9947 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9949 if (Candidates.empty())
9950 Diag(cast<Decl>(CanonDef)->getLocation(),
9951 diag::note_module_odr_violation_no_possible_decls) << D;
9953 for (
unsigned I = 0, N = Candidates.size(); I != N; ++I)
9954 Diag(Candidates[I]->getLocation(),
9955 diag::note_module_odr_violation_possible_decl)
9959 DiagnosedOdrMergeFailures.insert(CanonDef);
9963 if (OdrMergeFailures.empty() && RecordOdrMergeFailures.empty() &&
9964 FunctionOdrMergeFailures.empty() && EnumOdrMergeFailures.empty() &&
9965 ObjCInterfaceOdrMergeFailures.empty() &&
9966 ObjCProtocolOdrMergeFailures.empty())
9973 for (
auto &Merge : OdrMergeFailures) {
9976 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9979 bool Diagnosed =
false;
9981 for (
auto &RecordPair : Merge.second) {
9982 if (DiagsEmitter.diagnoseMismatch(FirstRecord, RecordPair.first,
9983 RecordPair.second)) {
9996 Diag(Merge.first->getLocation(),
9997 diag::err_module_odr_violation_different_instantiations)
10004 for (
auto &Merge : RecordOdrMergeFailures) {
10007 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10011 bool Diagnosed =
false;
10012 for (
auto *SecondRecord : Merge.second) {
10013 if (DiagsEmitter.diagnoseMismatch(FirstRecord, SecondRecord)) {
10019 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10023 for (
auto &Merge : FunctionOdrMergeFailures) {
10025 bool Diagnosed =
false;
10026 for (
auto &SecondFunction : Merge.second) {
10027 if (DiagsEmitter.diagnoseMismatch(FirstFunction, SecondFunction)) {
10033 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10037 for (
auto &Merge : EnumOdrMergeFailures) {
10040 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10043 EnumDecl *FirstEnum = Merge.first;
10044 bool Diagnosed =
false;
10045 for (
auto &SecondEnum : Merge.second) {
10046 if (DiagsEmitter.diagnoseMismatch(FirstEnum, SecondEnum)) {
10052 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10055 for (
auto &Merge : ObjCInterfaceOdrMergeFailures) {
10058 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10061 bool Diagnosed =
false;
10063 for (
auto &InterfacePair : Merge.second) {
10064 if (DiagsEmitter.diagnoseMismatch(FirstID, InterfacePair.first,
10065 InterfacePair.second)) {
10071 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10074 for (
auto &Merge : ObjCProtocolOdrMergeFailures) {
10077 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10081 bool Diagnosed =
false;
10082 for (
auto &ProtocolPair : Merge.second) {
10083 if (DiagsEmitter.diagnoseMismatch(FirstProtocol, ProtocolPair.first,
10084 ProtocolPair.second)) {
10090 assert(Diagnosed &&
"Unable to emit ODR diagnostic.");
10095 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
10096 ReadTimer->startTimer();
10100 assert(NumCurrentElementsDeserializing &&
10101 "FinishedDeserializing not paired with StartedDeserializing");
10102 if (NumCurrentElementsDeserializing == 1) {
10105 finishPendingActions();
10107 --NumCurrentElementsDeserializing;
10109 if (NumCurrentElementsDeserializing == 0) {
10115 while (!PendingExceptionSpecUpdates.empty() ||
10116 !PendingDeducedTypeUpdates.empty()) {
10117 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
10118 PendingExceptionSpecUpdates.clear();
10119 for (
auto Update : ESUpdates) {
10120 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10124 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(
Update.second));
10125 for (
auto *Redecl :
Update.second->redecls())
10129 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
10130 PendingDeducedTypeUpdates.clear();
10131 for (
auto Update : DTUpdates) {
10132 ProcessingUpdatesRAIIObj ProcessingUpdates(*
this);
10138 auto UDTUpdates = std::move(PendingUndeducedFunctionDecls);
10139 PendingUndeducedFunctionDecls.clear();
10143 (void)UndeducedFD->getMostRecentDecl();
10147 ReadTimer->stopTimer();
10149 diagnoseOdrViolations();
10154 PassInterestingDeclsToConsumer();
10161 auto It = PendingFakeLookupResults.find(II);
10162 if (It != PendingFakeLookupResults.end()) {
10163 for (
auto *ND : It->second)
10168 It->second.clear();
10174 }
else if (SemaObj->
TUScope) {
10186 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
10187 StringRef isysroot,
10189 bool AllowASTWithCompilerErrors,
10190 bool AllowConfigurationMismatch,
bool ValidateSystemInputs,
10191 bool ValidateASTInputFilesContent,
bool UseGlobalIndex,
10192 std::unique_ptr<llvm::Timer> ReadTimer)
10196 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
10197 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
10198 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
10199 PCHContainerRdr, PP.getHeaderSearchInfo()),
10200 DummyIdResolver(PP), ReadTimer(
std::move(ReadTimer)), isysroot(isysroot),
10201 DisableValidationKind(DisableValidationKind),
10202 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
10203 AllowConfigurationMismatch(AllowConfigurationMismatch),
10204 ValidateSystemInputs(ValidateSystemInputs),
10205 ValidateASTInputFilesContent(ValidateASTInputFilesContent),
10206 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
10209 for (
const auto &Ext : Extensions) {
10210 auto BlockName = Ext->getExtensionMetadata().BlockName;
10211 auto Known = ModuleFileExtensions.find(BlockName);
10212 if (Known != ModuleFileExtensions.end()) {
10213 Diags.
Report(diag::warn_duplicate_module_file_extension)
10218 ModuleFileExtensions.insert({BlockName, Ext});
10223 if (OwnsDeserializationListener)
10224 delete DeserializationListener;
10228 return SemaObj ? SemaObj->
IdResolver : DummyIdResolver;
10232 unsigned AbbrevID) {
10235 return Cursor.readRecord(AbbrevID,
Record);
10252#define GEN_CLANG_CLAUSE_CLASS
10253#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
10254#include "llvm/Frontend/OpenMP/OMP.inc"
10268 switch (llvm::omp::Clause(
Record.readInt())) {
10269 case llvm::omp::OMPC_if:
10272 case llvm::omp::OMPC_final:
10275 case llvm::omp::OMPC_num_threads:
10278 case llvm::omp::OMPC_safelen:
10281 case llvm::omp::OMPC_simdlen:
10284 case llvm::omp::OMPC_sizes: {
10285 unsigned NumSizes =
Record.readInt();
10289 case llvm::omp::OMPC_full:
10292 case llvm::omp::OMPC_partial:
10295 case llvm::omp::OMPC_allocator:
10298 case llvm::omp::OMPC_collapse:
10301 case llvm::omp::OMPC_default:
10304 case llvm::omp::OMPC_proc_bind:
10307 case llvm::omp::OMPC_schedule:
10310 case llvm::omp::OMPC_ordered:
10313 case llvm::omp::OMPC_nowait:
10316 case llvm::omp::OMPC_untied:
10319 case llvm::omp::OMPC_mergeable:
10322 case llvm::omp::OMPC_read:
10325 case llvm::omp::OMPC_write:
10328 case llvm::omp::OMPC_update:
10331 case llvm::omp::OMPC_capture:
10334 case llvm::omp::OMPC_compare:
10337 case llvm::omp::OMPC_fail:
10340 case llvm::omp::OMPC_seq_cst:
10343 case llvm::omp::OMPC_acq_rel:
10346 case llvm::omp::OMPC_acquire:
10349 case llvm::omp::OMPC_release:
10352 case llvm::omp::OMPC_relaxed:
10355 case llvm::omp::OMPC_weak:
10358 case llvm::omp::OMPC_threads:
10361 case llvm::omp::OMPC_simd:
10364 case llvm::omp::OMPC_nogroup:
10367 case llvm::omp::OMPC_unified_address:
10370 case llvm::omp::OMPC_unified_shared_memory:
10373 case llvm::omp::OMPC_reverse_offload:
10376 case llvm::omp::OMPC_dynamic_allocators:
10379 case llvm::omp::OMPC_atomic_default_mem_order:
10382 case llvm::omp::OMPC_at:
10385 case llvm::omp::OMPC_severity:
10388 case llvm::omp::OMPC_message:
10391 case llvm::omp::OMPC_private:
10394 case llvm::omp::OMPC_firstprivate:
10397 case llvm::omp::OMPC_lastprivate:
10400 case llvm::omp::OMPC_shared:
10403 case llvm::omp::OMPC_reduction: {
10404 unsigned N =
Record.readInt();
10409 case llvm::omp::OMPC_task_reduction:
10412 case llvm::omp::OMPC_in_reduction:
10415 case llvm::omp::OMPC_linear:
10418 case llvm::omp::OMPC_aligned:
10421 case llvm::omp::OMPC_copyin:
10424 case llvm::omp::OMPC_copyprivate:
10427 case llvm::omp::OMPC_flush:
10430 case llvm::omp::OMPC_depobj:
10433 case llvm::omp::OMPC_depend: {
10434 unsigned NumVars =
Record.readInt();
10435 unsigned NumLoops =
Record.readInt();
10439 case llvm::omp::OMPC_device:
10442 case llvm::omp::OMPC_map: {
10451 case llvm::omp::OMPC_num_teams:
10454 case llvm::omp::OMPC_thread_limit:
10457 case llvm::omp::OMPC_priority:
10460 case llvm::omp::OMPC_grainsize:
10463 case llvm::omp::OMPC_num_tasks:
10466 case llvm::omp::OMPC_hint:
10469 case llvm::omp::OMPC_dist_schedule:
10472 case llvm::omp::OMPC_defaultmap:
10475 case llvm::omp::OMPC_to: {
10484 case llvm::omp::OMPC_from: {
10493 case llvm::omp::OMPC_use_device_ptr: {
10502 case llvm::omp::OMPC_use_device_addr: {
10511 case llvm::omp::OMPC_is_device_ptr: {
10520 case llvm::omp::OMPC_has_device_addr: {
10529 case llvm::omp::OMPC_allocate:
10532 case llvm::omp::OMPC_nontemporal:
10535 case llvm::omp::OMPC_inclusive:
10538 case llvm::omp::OMPC_exclusive:
10541 case llvm::omp::OMPC_order:
10544 case llvm::omp::OMPC_init:
10547 case llvm::omp::OMPC_use:
10550 case llvm::omp::OMPC_destroy:
10553 case llvm::omp::OMPC_novariants:
10556 case llvm::omp::OMPC_nocontext:
10559 case llvm::omp::OMPC_detach:
10562 case llvm::omp::OMPC_uses_allocators:
10565 case llvm::omp::OMPC_affinity:
10568 case llvm::omp::OMPC_filter:
10571 case llvm::omp::OMPC_bind:
10574 case llvm::omp::OMPC_align:
10577 case llvm::omp::OMPC_ompx_dyn_cgroup_mem:
10580 case llvm::omp::OMPC_doacross: {
10581 unsigned NumVars =
Record.readInt();
10582 unsigned NumLoops =
Record.readInt();
10586 case llvm::omp::OMPC_ompx_attribute:
10589 case llvm::omp::OMPC_ompx_bare:
10592#define OMP_CLAUSE_NO_CLASS(Enum, Str) \
10593 case llvm::omp::Enum: \
10595#include "llvm/Frontend/OpenMP/OMPKinds.def"
10599 assert(
C &&
"Unknown OMPClause type");
10602 C->setLocStart(
Record.readSourceLocation());
10603 C->setLocEnd(
Record.readSourceLocation());
10609 C->setPreInitStmt(
Record.readSubStmt(),
10615 C->setPostUpdateExpr(
Record.readSubExpr());
10618void OMPClauseReader::VisitOMPIfClause(
OMPIfClause *
C) {
10621 C->setNameModifierLoc(
Record.readSourceLocation());
10622 C->setColonLoc(
Record.readSourceLocation());
10623 C->setCondition(
Record.readSubExpr());
10624 C->setLParenLoc(
Record.readSourceLocation());
10629 C->setCondition(
Record.readSubExpr());
10630 C->setLParenLoc(
Record.readSourceLocation());
10635 C->setNumThreads(
Record.readSubExpr());
10636 C->setLParenLoc(
Record.readSourceLocation());
10640 C->setSafelen(
Record.readSubExpr());
10641 C->setLParenLoc(
Record.readSourceLocation());
10645 C->setSimdlen(
Record.readSubExpr());
10646 C->setLParenLoc(
Record.readSourceLocation());
10650 for (
Expr *&E :
C->getSizesRefs())
10651 E =
Record.readSubExpr();
10652 C->setLParenLoc(
Record.readSourceLocation());
10658 C->setFactor(
Record.readSubExpr());
10659 C->setLParenLoc(
Record.readSourceLocation());
10663 C->setAllocator(
Record.readExpr());
10664 C->setLParenLoc(
Record.readSourceLocation());
10668 C->setNumForLoops(
Record.readSubExpr());
10669 C->setLParenLoc(
Record.readSourceLocation());
10673 C->setDefaultKind(
static_cast<llvm::omp::DefaultKind
>(
Record.readInt()));
10674 C->setLParenLoc(
Record.readSourceLocation());
10675 C->setDefaultKindKwLoc(
Record.readSourceLocation());
10679 C->setProcBindKind(
static_cast<llvm::omp::ProcBindKind
>(
Record.readInt()));
10680 C->setLParenLoc(
Record.readSourceLocation());
10681 C->setProcBindKindKwLoc(
Record.readSourceLocation());
10686 C->setScheduleKind(
10688 C->setFirstScheduleModifier(
10690 C->setSecondScheduleModifier(
10692 C->setChunkSize(
Record.readSubExpr());
10693 C->setLParenLoc(
Record.readSourceLocation());
10694 C->setFirstScheduleModifierLoc(
Record.readSourceLocation());
10695 C->setSecondScheduleModifierLoc(
Record.readSourceLocation());
10696 C->setScheduleKindLoc(
Record.readSourceLocation());
10697 C->setCommaLoc(
Record.readSourceLocation());
10701 C->setNumForLoops(
Record.readSubExpr());
10702 for (
unsigned I = 0, E =
C->NumberOfLoops; I < E; ++I)
10703 C->setLoopNumIterations(I,
Record.readSubExpr());
10704 for (
unsigned I = 0, E =
C->NumberOfLoops; I < E; ++I)
10705 C->setLoopCounter(I,
Record.readSubExpr());
10706 C->setLParenLoc(
Record.readSourceLocation());
10710 C->setEventHandler(
Record.readSubExpr());
10711 C->setLParenLoc(
Record.readSourceLocation());
10720void OMPClauseReader::VisitOMPReadClause(
OMPReadClause *) {}
10725 if (
C->isExtended()) {
10726 C->setLParenLoc(
Record.readSourceLocation());
10727 C->setArgumentLoc(
Record.readSourceLocation());
10739 C->setLParenLoc(
Record.readSourceLocation());
10741 C->setFailParameterLoc(FailParameterLoc);
10743 C->setFailParameter(CKind);
10756void OMPClauseReader::VisitOMPWeakClause(
OMPWeakClause *) {}
10760void OMPClauseReader::VisitOMPSIMDClause(
OMPSIMDClause *) {}
10765 unsigned NumVars =
C->varlist_size();
10767 Vars.reserve(NumVars);
10768 for (
unsigned I = 0; I != NumVars; ++I)
10769 Vars.push_back(
Record.readSubExpr());
10770 C->setVarRefs(Vars);
10771 C->setIsTarget(
Record.readBool());
10772 C->setIsTargetSync(
Record.readBool());
10773 C->setLParenLoc(
Record.readSourceLocation());
10774 C->setVarLoc(
Record.readSourceLocation());
10778 C->setInteropVar(
Record.readSubExpr());
10779 C->setLParenLoc(
Record.readSourceLocation());
10780 C->setVarLoc(
Record.readSourceLocation());
10784 C->setInteropVar(
Record.readSubExpr());
10785 C->setLParenLoc(
Record.readSourceLocation());
10786 C->setVarLoc(
Record.readSourceLocation());
10791 C->setCondition(
Record.readSubExpr());
10792 C->setLParenLoc(
Record.readSourceLocation());
10797 C->setCondition(
Record.readSubExpr());
10798 C->setLParenLoc(
Record.readSourceLocation());
10803void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
10812void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
10814 C->setAtomicDefaultMemOrderKind(
10816 C->setLParenLoc(
Record.readSourceLocation());
10817 C->setAtomicDefaultMemOrderKindKwLoc(
Record.readSourceLocation());
10820void OMPClauseReader::VisitOMPAtClause(
OMPAtClause *
C) {
10822 C->setLParenLoc(
Record.readSourceLocation());
10823 C->setAtKindKwLoc(
Record.readSourceLocation());
10828 C->setLParenLoc(
Record.readSourceLocation());
10829 C->setSeverityKindKwLoc(
Record.readSourceLocation());
10833 C->setMessageString(
Record.readSubExpr());
10834 C->setLParenLoc(
Record.readSourceLocation());
10838 C->setLParenLoc(
Record.readSourceLocation());
10839 unsigned NumVars =
C->varlist_size();
10841 Vars.reserve(NumVars);
10842 for (
unsigned i = 0; i != NumVars; ++i)
10843 Vars.push_back(
Record.readSubExpr());
10844 C->setVarRefs(Vars);
10846 for (
unsigned i = 0; i != NumVars; ++i)
10847 Vars.push_back(
Record.readSubExpr());
10848 C->setPrivateCopies(Vars);
10853 C->setLParenLoc(
Record.readSourceLocation());
10854 unsigned NumVars =
C->varlist_size();
10856 Vars.reserve(NumVars);
10857 for (
unsigned i = 0; i != NumVars; ++i)
10858 Vars.push_back(
Record.readSubExpr());
10859 C->setVarRefs(Vars);
10861 for (
unsigned i = 0; i != NumVars; ++i)
10862 Vars.push_back(
Record.readSubExpr());
10863 C->setPrivateCopies(Vars);
10865 for (
unsigned i = 0; i != NumVars; ++i)
10866 Vars.push_back(
Record.readSubExpr());
10872 C->setLParenLoc(
Record.readSourceLocation());
10874 C->setKindLoc(
Record.readSourceLocation());
10875 C->setColonLoc(
Record.readSourceLocation());
10876 unsigned NumVars =
C->varlist_size();
10878 Vars.reserve(NumVars);
10879 for (
unsigned i = 0; i != NumVars; ++i)
10880 Vars.push_back(
Record.readSubExpr());
10881 C->setVarRefs(Vars);
10883 for (
unsigned i = 0; i != NumVars; ++i)
10884 Vars.push_back(
Record.readSubExpr());
10885 C->setPrivateCopies(Vars);
10887 for (
unsigned i = 0; i != NumVars; ++i)
10888 Vars.push_back(
Record.readSubExpr());
10889 C->setSourceExprs(Vars);
10891 for (
unsigned i = 0; i != NumVars; ++i)
10892 Vars.push_back(
Record.readSubExpr());
10893 C->setDestinationExprs(Vars);
10895 for (
unsigned i = 0; i != NumVars; ++i)
10896 Vars.push_back(
Record.readSubExpr());
10897 C->setAssignmentOps(Vars);
10901 C->setLParenLoc(
Record.readSourceLocation());
10902 unsigned NumVars =
C->varlist_size();
10904 Vars.reserve(NumVars);
10905 for (
unsigned i = 0; i != NumVars; ++i)
10906 Vars.push_back(
Record.readSubExpr());
10907 C->setVarRefs(Vars);
10912 C->setLParenLoc(
Record.readSourceLocation());
10913 C->setModifierLoc(
Record.readSourceLocation());
10914 C->setColonLoc(
Record.readSourceLocation());
10917 C->setQualifierLoc(NNSL);
10918 C->setNameInfo(DNI);
10920 unsigned NumVars =
C->varlist_size();
10922 Vars.reserve(NumVars);
10923 for (
unsigned i = 0; i != NumVars; ++i)
10924 Vars.push_back(
Record.readSubExpr());
10925 C->setVarRefs(Vars);
10927 for (
unsigned i = 0; i != NumVars; ++i)
10928 Vars.push_back(
Record.readSubExpr());
10929 C->setPrivates(Vars);
10931 for (
unsigned i = 0; i != NumVars; ++i)
10932 Vars.push_back(
Record.readSubExpr());
10933 C->setLHSExprs(Vars);
10935 for (
unsigned i = 0; i != NumVars; ++i)
10936 Vars.push_back(
Record.readSubExpr());
10937 C->setRHSExprs(Vars);
10939 for (
unsigned i = 0; i != NumVars; ++i)
10940 Vars.push_back(
Record.readSubExpr());
10941 C->setReductionOps(Vars);
10942 if (
C->getModifier() == OMPC_REDUCTION_inscan) {
10944 for (
unsigned i = 0; i != NumVars; ++i)
10945 Vars.push_back(
Record.readSubExpr());
10946 C->setInscanCopyOps(Vars);
10948 for (
unsigned i = 0; i != NumVars; ++i)
10949 Vars.push_back(
Record.readSubExpr());
10950 C->setInscanCopyArrayTemps(Vars);
10952 for (
unsigned i = 0; i != NumVars; ++i)
10953 Vars.push_back(
Record.readSubExpr());
10954 C->setInscanCopyArrayElems(Vars);
10960 C->setLParenLoc(
Record.readSourceLocation());
10961 C->setColonLoc(
Record.readSourceLocation());
10964 C->setQualifierLoc(NNSL);
10965 C->setNameInfo(DNI);
10967 unsigned NumVars =
C->varlist_size();
10969 Vars.reserve(NumVars);
10970 for (
unsigned I = 0; I != NumVars; ++I)
10971 Vars.push_back(
Record.readSubExpr());
10972 C->setVarRefs(Vars);
10974 for (
unsigned I = 0; I != NumVars; ++I)
10975 Vars.push_back(
Record.readSubExpr());
10976 C->setPrivates(Vars);
10978 for (
unsigned I = 0; I != NumVars; ++I)
10979 Vars.push_back(
Record.readSubExpr());
10980 C->setLHSExprs(Vars);
10982 for (
unsigned I = 0; I != NumVars; ++I)
10983 Vars.push_back(
Record.readSubExpr());
10984 C->setRHSExprs(Vars);
10986 for (
unsigned I = 0; I != NumVars; ++I)
10987 Vars.push_back(
Record.readSubExpr());
10988 C->setReductionOps(Vars);
10993 C->setLParenLoc(
Record.readSourceLocation());
10994 C->setColonLoc(
Record.readSourceLocation());
10997 C->setQualifierLoc(NNSL);
10998 C->setNameInfo(DNI);
11000 unsigned NumVars =
C->varlist_size();
11002 Vars.reserve(NumVars);
11003 for (
unsigned I = 0; I != NumVars; ++I)
11004 Vars.push_back(
Record.readSubExpr());
11005 C->setVarRefs(Vars);
11007 for (
unsigned I = 0; I != NumVars; ++I)
11008 Vars.push_back(
Record.readSubExpr());
11009 C->setPrivates(Vars);
11011 for (
unsigned I = 0; I != NumVars; ++I)
11012 Vars.push_back(
Record.readSubExpr());
11013 C->setLHSExprs(Vars);
11015 for (
unsigned I = 0; I != NumVars; ++I)
11016 Vars.push_back(
Record.readSubExpr());
11017 C->setRHSExprs(Vars);
11019 for (
unsigned I = 0; I != NumVars; ++I)
11020 Vars.push_back(
Record.readSubExpr());
11021 C->setReductionOps(Vars);
11023 for (
unsigned I = 0; I != NumVars; ++I)
11024 Vars.push_back(
Record.readSubExpr());
11025 C->setTaskgroupDescriptors(Vars);
11030 C->setLParenLoc(
Record.readSourceLocation());
11031 C->setColonLoc(
Record.readSourceLocation());
11033 C->setModifierLoc(
Record.readSourceLocation());
11034 unsigned NumVars =
C->varlist_size();
11036 Vars.reserve(NumVars);
11037 for (
unsigned i = 0; i != NumVars; ++i)
11038 Vars.push_back(
Record.readSubExpr());
11039 C->setVarRefs(Vars);
11041 for (
unsigned i = 0; i != NumVars; ++i)
11042 Vars.push_back(
Record.readSubExpr());
11043 C->setPrivates(Vars);
11045 for (
unsigned i = 0; i != NumVars; ++i)
11046 Vars.push_back(
Record.readSubExpr());
11049 for (
unsigned i = 0; i != NumVars; ++i)
11050 Vars.push_back(
Record.readSubExpr());
11051 C->setUpdates(Vars);
11053 for (
unsigned i = 0; i != NumVars; ++i)
11054 Vars.push_back(
Record.readSubExpr());
11055 C->setFinals(Vars);
11056 C->setStep(
Record.readSubExpr());
11057 C->setCalcStep(
Record.readSubExpr());
11059 for (
unsigned I = 0; I != NumVars + 1; ++I)
11060 Vars.push_back(
Record.readSubExpr());
11061 C->setUsedExprs(Vars);
11065 C->setLParenLoc(
Record.readSourceLocation());
11066 C->setColonLoc(
Record.readSourceLocation());
11067 unsigned NumVars =
C->varlist_size();
11069 Vars.reserve(NumVars);
11070 for (
unsigned i = 0; i != NumVars; ++i)
11071 Vars.push_back(
Record.readSubExpr());
11072 C->setVarRefs(Vars);
11073 C->setAlignment(
Record.readSubExpr());
11077 C->setLParenLoc(
Record.readSourceLocation());
11078 unsigned NumVars =
C->varlist_size();
11080 Exprs.reserve(NumVars);
11081 for (
unsigned i = 0; i != NumVars; ++i)
11082 Exprs.push_back(
Record.readSubExpr());
11083 C->setVarRefs(Exprs);
11085 for (
unsigned i = 0; i != NumVars; ++i)
11086 Exprs.push_back(
Record.readSubExpr());
11087 C->setSourceExprs(Exprs);
11089 for (
unsigned i = 0; i != NumVars; ++i)
11090 Exprs.push_back(
Record.readSubExpr());
11091 C->setDestinationExprs(Exprs);
11093 for (
unsigned i = 0; i != NumVars; ++i)
11094 Exprs.push_back(
Record.readSubExpr());
11095 C->setAssignmentOps(Exprs);
11099 C->setLParenLoc(
Record.readSourceLocation());
11100 unsigned NumVars =
C->varlist_size();
11102 Exprs.reserve(NumVars);
11103 for (
unsigned i = 0; i != NumVars; ++i)
11104 Exprs.push_back(
Record.readSubExpr());
11105 C->setVarRefs(Exprs);
11107 for (
unsigned i = 0; i != NumVars; ++i)
11108 Exprs.push_back(
Record.readSubExpr());
11109 C->setSourceExprs(Exprs);
11111 for (
unsigned i = 0; i != NumVars; ++i)
11112 Exprs.push_back(
Record.readSubExpr());
11113 C->setDestinationExprs(Exprs);
11115 for (
unsigned i = 0; i != NumVars; ++i)
11116 Exprs.push_back(
Record.readSubExpr());
11117 C->setAssignmentOps(Exprs);
11121 C->setLParenLoc(
Record.readSourceLocation());
11122 unsigned NumVars =
C->varlist_size();
11124 Vars.reserve(NumVars);
11125 for (
unsigned i = 0; i != NumVars; ++i)
11126 Vars.push_back(
Record.readSubExpr());
11127 C->setVarRefs(Vars);
11131 C->setDepobj(
Record.readSubExpr());
11132 C->setLParenLoc(
Record.readSourceLocation());
11136 C->setLParenLoc(
Record.readSourceLocation());
11137 C->setModifier(
Record.readSubExpr());
11138 C->setDependencyKind(
11140 C->setDependencyLoc(
Record.readSourceLocation());
11141 C->setColonLoc(
Record.readSourceLocation());
11142 C->setOmpAllMemoryLoc(
Record.readSourceLocation());
11143 unsigned NumVars =
C->varlist_size();
11145 Vars.reserve(NumVars);
11146 for (
unsigned I = 0; I != NumVars; ++I)
11147 Vars.push_back(
Record.readSubExpr());
11148 C->setVarRefs(Vars);
11149 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
11150 C->setLoopData(I,
Record.readSubExpr());
11156 C->setDevice(
Record.readSubExpr());
11157 C->setModifierLoc(
Record.readSourceLocation());
11158 C->setLParenLoc(
Record.readSourceLocation());
11162 C->setLParenLoc(
Record.readSourceLocation());
11163 bool HasIteratorModifier =
false;
11165 C->setMapTypeModifier(
11167 C->setMapTypeModifierLoc(I,
Record.readSourceLocation());
11168 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
11169 HasIteratorModifier =
true;
11171 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11172 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11175 C->setMapLoc(
Record.readSourceLocation());
11176 C->setColonLoc(
Record.readSourceLocation());
11177 auto NumVars =
C->varlist_size();
11178 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11179 auto TotalLists =
C->getTotalComponentListNum();
11180 auto TotalComponents =
C->getTotalComponentsNum();
11183 Vars.reserve(NumVars);
11184 for (
unsigned i = 0; i != NumVars; ++i)
11185 Vars.push_back(
Record.readExpr());
11186 C->setVarRefs(Vars);
11189 UDMappers.reserve(NumVars);
11190 for (
unsigned I = 0; I < NumVars; ++I)
11191 UDMappers.push_back(
Record.readExpr());
11192 C->setUDMapperRefs(UDMappers);
11194 if (HasIteratorModifier)
11195 C->setIteratorModifier(
Record.readExpr());
11198 Decls.reserve(UniqueDecls);
11199 for (
unsigned i = 0; i < UniqueDecls; ++i)
11201 C->setUniqueDecls(Decls);
11204 ListsPerDecl.reserve(UniqueDecls);
11205 for (
unsigned i = 0; i < UniqueDecls; ++i)
11206 ListsPerDecl.push_back(
Record.readInt());
11207 C->setDeclNumLists(ListsPerDecl);
11210 ListSizes.reserve(TotalLists);
11211 for (
unsigned i = 0; i < TotalLists; ++i)
11212 ListSizes.push_back(
Record.readInt());
11213 C->setComponentListSizes(ListSizes);
11216 Components.reserve(TotalComponents);
11217 for (
unsigned i = 0; i < TotalComponents; ++i) {
11220 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11223 C->setComponents(Components, ListSizes);
11227 C->setLParenLoc(
Record.readSourceLocation());
11228 C->setColonLoc(
Record.readSourceLocation());
11229 C->setAllocator(
Record.readSubExpr());
11230 unsigned NumVars =
C->varlist_size();
11232 Vars.reserve(NumVars);
11233 for (
unsigned i = 0; i != NumVars; ++i)
11234 Vars.push_back(
Record.readSubExpr());
11235 C->setVarRefs(Vars);
11240 C->setNumTeams(
Record.readSubExpr());
11241 C->setLParenLoc(
Record.readSourceLocation());
11246 C->setThreadLimit(
Record.readSubExpr());
11247 C->setLParenLoc(
Record.readSourceLocation());
11252 C->setPriority(
Record.readSubExpr());
11253 C->setLParenLoc(
Record.readSourceLocation());
11259 C->setGrainsize(
Record.readSubExpr());
11260 C->setModifierLoc(
Record.readSourceLocation());
11261 C->setLParenLoc(
Record.readSourceLocation());
11267 C->setNumTasks(
Record.readSubExpr());
11268 C->setModifierLoc(
Record.readSourceLocation());
11269 C->setLParenLoc(
Record.readSourceLocation());
11273 C->setHint(
Record.readSubExpr());
11274 C->setLParenLoc(
Record.readSourceLocation());
11279 C->setDistScheduleKind(
11281 C->setChunkSize(
Record.readSubExpr());
11282 C->setLParenLoc(
Record.readSourceLocation());
11283 C->setDistScheduleKindLoc(
Record.readSourceLocation());
11284 C->setCommaLoc(
Record.readSourceLocation());
11288 C->setDefaultmapKind(
11290 C->setDefaultmapModifier(
11292 C->setLParenLoc(
Record.readSourceLocation());
11293 C->setDefaultmapModifierLoc(
Record.readSourceLocation());
11294 C->setDefaultmapKindLoc(
Record.readSourceLocation());
11297void OMPClauseReader::VisitOMPToClause(
OMPToClause *
C) {
11298 C->setLParenLoc(
Record.readSourceLocation());
11300 C->setMotionModifier(
11302 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11304 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11305 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11306 C->setColonLoc(
Record.readSourceLocation());
11307 auto NumVars =
C->varlist_size();
11308 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11309 auto TotalLists =
C->getTotalComponentListNum();
11310 auto TotalComponents =
C->getTotalComponentsNum();
11313 Vars.reserve(NumVars);
11314 for (
unsigned i = 0; i != NumVars; ++i)
11315 Vars.push_back(
Record.readSubExpr());
11316 C->setVarRefs(Vars);
11319 UDMappers.reserve(NumVars);
11320 for (
unsigned I = 0; I < NumVars; ++I)
11321 UDMappers.push_back(
Record.readSubExpr());
11322 C->setUDMapperRefs(UDMappers);
11325 Decls.reserve(UniqueDecls);
11326 for (
unsigned i = 0; i < UniqueDecls; ++i)
11328 C->setUniqueDecls(Decls);
11331 ListsPerDecl.reserve(UniqueDecls);
11332 for (
unsigned i = 0; i < UniqueDecls; ++i)
11333 ListsPerDecl.push_back(
Record.readInt());
11334 C->setDeclNumLists(ListsPerDecl);
11337 ListSizes.reserve(TotalLists);
11338 for (
unsigned i = 0; i < TotalLists; ++i)
11339 ListSizes.push_back(
Record.readInt());
11340 C->setComponentListSizes(ListSizes);
11343 Components.reserve(TotalComponents);
11344 for (
unsigned i = 0; i < TotalComponents; ++i) {
11345 Expr *AssociatedExprPr =
Record.readSubExpr();
11346 bool IsNonContiguous =
Record.readBool();
11348 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11350 C->setComponents(Components, ListSizes);
11354 C->setLParenLoc(
Record.readSourceLocation());
11356 C->setMotionModifier(
11358 C->setMotionModifierLoc(I,
Record.readSourceLocation());
11360 C->setMapperQualifierLoc(
Record.readNestedNameSpecifierLoc());
11361 C->setMapperIdInfo(
Record.readDeclarationNameInfo());
11362 C->setColonLoc(
Record.readSourceLocation());
11363 auto NumVars =
C->varlist_size();
11364 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11365 auto TotalLists =
C->getTotalComponentListNum();
11366 auto TotalComponents =
C->getTotalComponentsNum();
11369 Vars.reserve(NumVars);
11370 for (
unsigned i = 0; i != NumVars; ++i)
11371 Vars.push_back(
Record.readSubExpr());
11372 C->setVarRefs(Vars);
11375 UDMappers.reserve(NumVars);
11376 for (
unsigned I = 0; I < NumVars; ++I)
11377 UDMappers.push_back(
Record.readSubExpr());
11378 C->setUDMapperRefs(UDMappers);
11381 Decls.reserve(UniqueDecls);
11382 for (
unsigned i = 0; i < UniqueDecls; ++i)
11384 C->setUniqueDecls(Decls);
11387 ListsPerDecl.reserve(UniqueDecls);
11388 for (
unsigned i = 0; i < UniqueDecls; ++i)
11389 ListsPerDecl.push_back(
Record.readInt());
11390 C->setDeclNumLists(ListsPerDecl);
11393 ListSizes.reserve(TotalLists);
11394 for (
unsigned i = 0; i < TotalLists; ++i)
11395 ListSizes.push_back(
Record.readInt());
11396 C->setComponentListSizes(ListSizes);
11399 Components.reserve(TotalComponents);
11400 for (
unsigned i = 0; i < TotalComponents; ++i) {
11401 Expr *AssociatedExprPr =
Record.readSubExpr();
11402 bool IsNonContiguous =
Record.readBool();
11404 Components.emplace_back(AssociatedExprPr, AssociatedDecl, IsNonContiguous);
11406 C->setComponents(Components, ListSizes);
11410 C->setLParenLoc(
Record.readSourceLocation());
11411 auto NumVars =
C->varlist_size();
11412 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11413 auto TotalLists =
C->getTotalComponentListNum();
11414 auto TotalComponents =
C->getTotalComponentsNum();
11417 Vars.reserve(NumVars);
11418 for (
unsigned i = 0; i != NumVars; ++i)
11419 Vars.push_back(
Record.readSubExpr());
11420 C->setVarRefs(Vars);
11422 for (
unsigned i = 0; i != NumVars; ++i)
11423 Vars.push_back(
Record.readSubExpr());
11424 C->setPrivateCopies(Vars);
11426 for (
unsigned i = 0; i != NumVars; ++i)
11427 Vars.push_back(
Record.readSubExpr());
11431 Decls.reserve(UniqueDecls);
11432 for (
unsigned i = 0; i < UniqueDecls; ++i)
11434 C->setUniqueDecls(Decls);
11437 ListsPerDecl.reserve(UniqueDecls);
11438 for (
unsigned i = 0; i < UniqueDecls; ++i)
11439 ListsPerDecl.push_back(
Record.readInt());
11440 C->setDeclNumLists(ListsPerDecl);
11443 ListSizes.reserve(TotalLists);
11444 for (
unsigned i = 0; i < TotalLists; ++i)
11445 ListSizes.push_back(
Record.readInt());
11446 C->setComponentListSizes(ListSizes);
11449 Components.reserve(TotalComponents);
11450 for (
unsigned i = 0; i < TotalComponents; ++i) {
11451 auto *AssociatedExprPr =
Record.readSubExpr();
11453 Components.emplace_back(AssociatedExprPr, AssociatedDecl,
11456 C->setComponents(Components, ListSizes);
11460 C->setLParenLoc(
Record.readSourceLocation());
11461 auto NumVars =
C->varlist_size();
11462 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11463 auto TotalLists =
C->getTotalComponentListNum();
11464 auto TotalComponents =
C->getTotalComponentsNum();
11467 Vars.reserve(NumVars);
11468 for (
unsigned i = 0; i != NumVars; ++i)
11469 Vars.push_back(
Record.readSubExpr());
11470 C->setVarRefs(Vars);
11473 Decls.reserve(UniqueDecls);
11474 for (
unsigned i = 0; i < UniqueDecls; ++i)
11476 C->setUniqueDecls(Decls);
11479 ListsPerDecl.reserve(UniqueDecls);
11480 for (
unsigned i = 0; i < UniqueDecls; ++i)
11481 ListsPerDecl.push_back(
Record.readInt());
11482 C->setDeclNumLists(ListsPerDecl);
11485 ListSizes.reserve(TotalLists);
11486 for (
unsigned i = 0; i < TotalLists; ++i)
11487 ListSizes.push_back(
Record.readInt());
11488 C->setComponentListSizes(ListSizes);
11491 Components.reserve(TotalComponents);
11492 for (
unsigned i = 0; i < TotalComponents; ++i) {
11493 Expr *AssociatedExpr =
Record.readSubExpr();
11495 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11498 C->setComponents(Components, ListSizes);
11502 C->setLParenLoc(
Record.readSourceLocation());
11503 auto NumVars =
C->varlist_size();
11504 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11505 auto TotalLists =
C->getTotalComponentListNum();
11506 auto TotalComponents =
C->getTotalComponentsNum();
11509 Vars.reserve(NumVars);
11510 for (
unsigned i = 0; i != NumVars; ++i)
11511 Vars.push_back(
Record.readSubExpr());
11512 C->setVarRefs(Vars);
11516 Decls.reserve(UniqueDecls);
11517 for (
unsigned i = 0; i < UniqueDecls; ++i)
11519 C->setUniqueDecls(Decls);
11522 ListsPerDecl.reserve(UniqueDecls);
11523 for (
unsigned i = 0; i < UniqueDecls; ++i)
11524 ListsPerDecl.push_back(
Record.readInt());
11525 C->setDeclNumLists(ListsPerDecl);
11528 ListSizes.reserve(TotalLists);
11529 for (
unsigned i = 0; i < TotalLists; ++i)
11530 ListSizes.push_back(
Record.readInt());
11531 C->setComponentListSizes(ListSizes);
11534 Components.reserve(TotalComponents);
11535 for (
unsigned i = 0; i < TotalComponents; ++i) {
11536 Expr *AssociatedExpr =
Record.readSubExpr();
11538 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11541 C->setComponents(Components, ListSizes);
11545 C->setLParenLoc(
Record.readSourceLocation());
11546 auto NumVars =
C->varlist_size();
11547 auto UniqueDecls =
C->getUniqueDeclarationsNum();
11548 auto TotalLists =
C->getTotalComponentListNum();
11549 auto TotalComponents =
C->getTotalComponentsNum();
11552 Vars.reserve(NumVars);
11553 for (
unsigned I = 0; I != NumVars; ++I)
11554 Vars.push_back(
Record.readSubExpr());
11555 C->setVarRefs(Vars);
11559 Decls.reserve(UniqueDecls);
11560 for (
unsigned I = 0; I < UniqueDecls; ++I)
11562 C->setUniqueDecls(Decls);
11565 ListsPerDecl.reserve(UniqueDecls);
11566 for (
unsigned I = 0; I < UniqueDecls; ++I)
11567 ListsPerDecl.push_back(
Record.readInt());
11568 C->setDeclNumLists(ListsPerDecl);
11571 ListSizes.reserve(TotalLists);
11572 for (
unsigned i = 0; i < TotalLists; ++i)
11573 ListSizes.push_back(
Record.readInt());
11574 C->setComponentListSizes(ListSizes);
11577 Components.reserve(TotalComponents);
11578 for (
unsigned I = 0; I < TotalComponents; ++I) {
11579 Expr *AssociatedExpr =
Record.readSubExpr();
11581 Components.emplace_back(AssociatedExpr, AssociatedDecl,
11584 C->setComponents(Components, ListSizes);
11588 C->setLParenLoc(
Record.readSourceLocation());
11589 unsigned NumVars =
C->varlist_size();
11591 Vars.reserve(NumVars);
11592 for (
unsigned i = 0; i != NumVars; ++i)
11593 Vars.push_back(
Record.readSubExpr());
11594 C->setVarRefs(Vars);
11596 Vars.reserve(NumVars);
11597 for (
unsigned i = 0; i != NumVars; ++i)
11598 Vars.push_back(
Record.readSubExpr());
11599 C->setPrivateRefs(Vars);
11603 C->setLParenLoc(
Record.readSourceLocation());
11604 unsigned NumVars =
C->varlist_size();
11606 Vars.reserve(NumVars);
11607 for (
unsigned i = 0; i != NumVars; ++i)
11608 Vars.push_back(
Record.readSubExpr());
11609 C->setVarRefs(Vars);
11613 C->setLParenLoc(
Record.readSourceLocation());
11614 unsigned NumVars =
C->varlist_size();
11616 Vars.reserve(NumVars);
11617 for (
unsigned i = 0; i != NumVars; ++i)
11618 Vars.push_back(
Record.readSubExpr());
11619 C->setVarRefs(Vars);
11623 C->setLParenLoc(
Record.readSourceLocation());
11624 unsigned NumOfAllocators =
C->getNumberOfAllocators();
11626 Data.reserve(NumOfAllocators);
11627 for (
unsigned I = 0; I != NumOfAllocators; ++I) {
11634 C->setAllocatorsData(
Data);
11638 C->setLParenLoc(
Record.readSourceLocation());
11639 C->setModifier(
Record.readSubExpr());
11640 C->setColonLoc(
Record.readSourceLocation());
11641 unsigned NumOfLocators =
C->varlist_size();
11643 Locators.reserve(NumOfLocators);
11644 for (
unsigned I = 0; I != NumOfLocators; ++I)
11645 Locators.push_back(
Record.readSubExpr());
11646 C->setVarRefs(Locators);
11652 C->setLParenLoc(
Record.readSourceLocation());
11653 C->setKindKwLoc(
Record.readSourceLocation());
11654 C->setModifierKwLoc(
Record.readSourceLocation());
11659 C->setThreadID(
Record.readSubExpr());
11660 C->setLParenLoc(
Record.readSourceLocation());
11665 C->setLParenLoc(
Record.readSourceLocation());
11666 C->setBindKindLoc(
Record.readSourceLocation());
11670 C->setAlignment(
Record.readExpr());
11671 C->setLParenLoc(
Record.readSourceLocation());
11676 C->setSize(
Record.readSubExpr());
11677 C->setLParenLoc(
Record.readSourceLocation());
11681 C->setLParenLoc(
Record.readSourceLocation());
11682 C->setDependenceType(
11684 C->setDependenceLoc(
Record.readSourceLocation());
11685 C->setColonLoc(
Record.readSourceLocation());
11686 unsigned NumVars =
C->varlist_size();
11688 Vars.reserve(NumVars);
11689 for (
unsigned I = 0; I != NumVars; ++I)
11690 Vars.push_back(
Record.readSubExpr());
11691 C->setVarRefs(Vars);
11692 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
11693 C->setLoopData(I,
Record.readSubExpr());
11698 Record.readAttributes(Attrs);
11699 C->setAttrs(Attrs);
11700 C->setLocStart(
Record.readSourceLocation());
11701 C->setLParenLoc(
Record.readSourceLocation());
11702 C->setLocEnd(
Record.readSourceLocation());
11711 Set.Kind = readEnum<llvm::omp::TraitSet>();
11714 Selector.Kind = readEnum<llvm::omp::TraitSelector>();
11715 Selector.ScoreOrCondition =
nullptr;
11717 Selector.ScoreOrCondition = readExprRef();
11720 Property.Kind = readEnum<llvm::omp::TraitProperty>();
11729 if (Reader->ReadingKind == ASTReader::Read_Stmt) {
11734 for (
unsigned I = 0, E =
Data->getNumClauses(); I < E; ++I)
11736 Data->setClauses(Clauses);
11737 if (
Data->hasAssociatedStmt())
11739 for (
unsigned I = 0, E =
Data->getNumChildren(); I < E; ++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 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 bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
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.
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes,...
Defines types useful for describing an Objective-C runtime.
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.
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 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...
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 > > &Exprs) override
void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl * > &Decls) override
Get the decls that are contained in a file in the Offset/Length range.
SourceRange ReadSkippedRange(unsigned Index) override
Read a preallocated skipped range from the external source.
Decl * GetDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
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.
Decl * GetLocalDecl(ModuleFile &F, uint32_t LocalID)
Reads a declaration with the given local ID in the given module.
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...
void updateOutOfDateIdentifier(IdentifierInfo &II) override
Update an out-of-date identifier.
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.
void SetGloballyVisibleDecls(IdentifierInfo *II, const SmallVectorImpl< uint32_t > &DeclIDs, SmallVectorImpl< Decl * > *Decls=nullptr)
Set the globally-visible declarations associated with the given identifier.
Decl * GetExternalDecl(uint32_t ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
llvm::Expected< SourceLocation::UIntTy > readSLocOffset(ModuleFile *F, unsigned Index)
Try to read the offset of the SLocEntry at the given index in the given module file.
Decl * GetExistingDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration.
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.
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)
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 markIdentifierUpToDate(IdentifierInfo *II)
Note that this identifier is up-to-date.
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WeakIDs) override
Read the set of weak, undeclared identifiers known to the external Sema source.
void completeVisibleDeclsMap(const DeclContext *DC) override
Load all external visible decls in the given DeclContext.
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
IdentifierResolver & getIdResolver()
Get the identifier resolver used for name lookup / updates in the translation unit scope.
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)
Read the control block for the named AST file.
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.
serialization::DeclID ReadDeclID(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a declaration ID from the given position in a record in the given module.
IdentifierInfo * DecodeIdentifierInfo(serialization::IdentifierID ID)
serialization::DeclID getGlobalDeclID(ModuleFile &F, serialization::LocalDeclID LocalID) const
Map from a local declaration ID within a given module to a global declaration 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.
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)
serialization::DeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, serialization::DeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
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)
SmallVector< uint64_t, 16 > PreloadedDeclIDs
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.
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 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()
serialization::DeclID readDeclID()
Reads a declaration ID from the given position in this record.
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)
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.
OMPTraitInfo * readOMPTraitInfo()
Read an OMPTraitInfo object, advancing Idx.
TemplateParameterList * readTemplateParameterList()
Read a template parameter list, advancing Idx.
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.
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
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.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
Kind
Lists the kind of concrete classes of Decl.
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
SourceLocation getLocation() const
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
unsigned getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
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.
static bool isModular(ModuleHeaderRole Role)
Check if the header with the given role is a modular one.
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 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.
QualType withFastQualifiers(unsigned TQs) const
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 getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
Selector getNullarySelector(IdentifierInfo *ID)
Selector getUnarySelector(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.
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...
SourceLocation getBeginLoc() const
Get the begin source location.
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
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.
ContinuousRangeMap< uint32_t, int, 2 > DeclRemap
Remapping table for declaration IDs in 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.
std::string ModuleMapPath
const DeclOffset * DeclOffsets
Offset of each declaration within the bitstream, indexed by the declaration ID (-1).
std::string getTimestampFilename() const
uint64_t MacroStartOffset
The offset of the start of the set of defined macros.
ASTFileSignature Signature
The signature of the module file, which may be used instead of the size and modification time to iden...
unsigned LocalNumMacros
The number of macros in this AST file.
unsigned NumPreprocessedSkippedRanges
const unsigned char * SelectorLookupTableData
A pointer to the character data that comprises the selector table.
const serialization::DeclID * FileSortedDecls
Array of file-level DeclIDs sorted by file.
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,.
@ 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.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
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.
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)
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.
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.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
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