81#include "llvm/ADT/APFloat.h"
82#include "llvm/ADT/APInt.h"
83#include "llvm/ADT/APSInt.h"
84#include "llvm/ADT/ArrayRef.h"
85#include "llvm/ADT/DenseMap.h"
86#include "llvm/ADT/DenseSet.h"
87#include "llvm/ADT/Hashing.h"
88#include "llvm/ADT/PointerIntPair.h"
89#include "llvm/ADT/STLExtras.h"
90#include "llvm/ADT/ScopeExit.h"
91#include "llvm/ADT/SmallPtrSet.h"
92#include "llvm/ADT/SmallString.h"
93#include "llvm/ADT/SmallVector.h"
94#include "llvm/ADT/StringMap.h"
95#include "llvm/ADT/StringRef.h"
96#include "llvm/Bitstream/BitCodes.h"
97#include "llvm/Bitstream/BitstreamWriter.h"
98#include "llvm/Support/Casting.h"
99#include "llvm/Support/Compression.h"
100#include "llvm/Support/DJB.h"
101#include "llvm/Support/Endian.h"
102#include "llvm/Support/EndianStream.h"
103#include "llvm/Support/Error.h"
104#include "llvm/Support/ErrorHandling.h"
105#include "llvm/Support/LEB128.h"
106#include "llvm/Support/MemoryBuffer.h"
107#include "llvm/Support/OnDiskHashTable.h"
108#include "llvm/Support/Path.h"
109#include "llvm/Support/SHA1.h"
110#include "llvm/Support/TimeProfiler.h"
111#include "llvm/Support/VersionTuple.h"
112#include "llvm/Support/raw_ostream.h"
127using namespace clang;
130template <
typename T,
typename Allocator>
131static StringRef
bytes(
const std::vector<T, Allocator> &
v) {
132 if (
v.empty())
return StringRef();
133 return StringRef(
reinterpret_cast<const char*
>(&
v[0]),
134 sizeof(
T) *
v.size());
139 return StringRef(
reinterpret_cast<const char*
>(
v.data()),
140 sizeof(
T) *
v.size());
143static std::string
bytes(
const std::vector<bool> &
V) {
145 Str.reserve(
V.size() / 8);
146 for (
unsigned I = 0,
E =
V.size(); I <
E;) {
148 for (
unsigned Bit = 0; Bit < 8 && I <
E; ++Bit, ++I)
161#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
162 case Type::CLASS_ID: return TYPE_##CODE_ID;
163#include "clang/Serialization/TypeBitCodes.def"
165 llvm_unreachable(
"shouldn't be serializing a builtin type this way");
167 llvm_unreachable(
"bad type kind");
172struct AffectingModuleMaps {
173 llvm::DenseSet<FileID> DefinitionFileIDs;
174 llvm::DenseSet<const FileEntry *> DefinitionFiles;
177std::optional<AffectingModuleMaps>
190 enum AffectedReason :
bool {
191 AR_TextualHeader = 0,
192 AR_ImportOrTextualHeader = 1,
194 auto AssignMostImportant = [](AffectedReason &LHS, AffectedReason RHS) {
195 LHS = std::max(LHS, RHS);
197 llvm::DenseMap<FileID, AffectedReason> ModuleMaps;
198 llvm::DenseMap<const Module *, AffectedReason> ProcessedModules;
199 auto CollectModuleMapsForHierarchy = [&](
const Module *M,
200 AffectedReason Reason) {
206 if (
auto [It, Inserted] = ProcessedModules.insert({M, Reason});
207 !Inserted && Reason <= It->second) {
213 std::queue<const Module *> Q;
216 const Module *Mod = Q.front();
222 AssignMostImportant(ModuleMaps[F], Reason);
227 AssignMostImportant(ModuleMaps[UniqF], Reason);
236 CollectModuleMapsForHierarchy(RootModule, AR_ImportOrTextualHeader);
238 std::queue<const Module *> Q;
241 const Module *CurrentModule = Q.front();
245 CollectModuleMapsForHierarchy(ImportedModule, AR_ImportOrTextualHeader);
247 CollectModuleMapsForHierarchy(UndeclaredModule, AR_ImportOrTextualHeader);
261 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
275 if (
const Module *M = KH.getModule())
276 CollectModuleMapsForHierarchy(M, AR_TextualHeader);
297 llvm::DenseSet<const FileEntry *> ModuleFileEntries;
298 llvm::DenseSet<FileID> ModuleFileIDs;
299 for (
auto [FID, Reason] : ModuleMaps) {
300 if (Reason == AR_ImportOrTextualHeader)
301 ModuleFileIDs.insert(FID);
302 if (
auto *FE =
SM.getFileEntryForID(FID))
303 ModuleFileEntries.insert(FE);
306 AffectingModuleMaps R;
307 R.DefinitionFileIDs = std::move(ModuleFileIDs);
308 R.DefinitionFiles = std::move(ModuleFileEntries);
319 : Writer(Writer), BasicWriter(Context, Writer,
Record) {}
322 if (
T.hasLocalNonFastQualifiers()) {
329 const Type *typePtr =
T.getTypePtr();
352#define ABSTRACT_TYPELOC(CLASS, PARENT)
353#define TYPELOC(CLASS, PARENT) \
354 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
355#include "clang/AST/TypeLocNodes.def"
423 VisitArrayTypeLoc(TL);
427 VisitArrayTypeLoc(TL);
431 VisitArrayTypeLoc(TL);
434void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
436 VisitArrayTypeLoc(TL);
439void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
443 addSourceLocation(
range.getBegin());
444 addSourceLocation(
range.getEnd());
448void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
457void TypeLocWriter::VisitDependentVectorTypeLoc(
469 addSourceLocation(
range.getBegin());
470 addSourceLocation(
range.getEnd());
475void TypeLocWriter::VisitDependentSizedMatrixTypeLoc(
479 addSourceLocation(
range.getBegin());
480 addSourceLocation(
range.getEnd());
491 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i)
496 VisitFunctionTypeLoc(TL);
500 VisitFunctionTypeLoc(TL);
565void TypeLocWriter::VisitAutoTypeLoc(
AutoTypeLoc TL) {
570 Record.AddConceptReference(CR);
576void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
585void TypeLocWriter::VisitEnumTypeLoc(
EnumTypeLoc TL) {
601void TypeLocWriter::VisitHLSLAttributedResourceTypeLoc(
610void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
615void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
620void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
626 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
655void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
699void TypeLocWriter::VisitPipeTypeLoc(
PipeTypeLoc TL) {
706void TypeLocWriter::VisitDependentBitIntTypeLoc(
711void ASTWriter::WriteTypeAbbrevs() {
712 using namespace llvm;
714 std::shared_ptr<BitCodeAbbrev> Abv;
717 Abv = std::make_shared<BitCodeAbbrev>();
719 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
720 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3));
721 TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv));
729 llvm::BitstreamWriter &Stream,
733 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID,
Record);
736 if (!Name || Name[0] == 0)
740 Record.push_back(*Name++);
741 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
Record);
745 llvm::BitstreamWriter &Stream,
750 Record.push_back(*Name++);
751 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME,
Record);
756#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
888void ASTWriter::WriteBlockInfoBlock() {
890 Stream.EnterBlockInfoBlock();
892#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
893#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
896 BLOCK(CONTROL_BLOCK);
906 BLOCK(OPTIONS_BLOCK);
913 BLOCK(INPUT_FILES_BLOCK);
978 BLOCK(SOURCE_MANAGER_BLOCK);
986 BLOCK(PREPROCESSOR_BLOCK);
994 BLOCK(SUBMODULE_BLOCK);
1016 BLOCK(COMMENTS_BLOCK);
1020 BLOCK(DECLTYPES_BLOCK);
1024 RECORD(TYPE_BLOCK_POINTER);
1025 RECORD(TYPE_LVALUE_REFERENCE);
1026 RECORD(TYPE_RVALUE_REFERENCE);
1027 RECORD(TYPE_MEMBER_POINTER);
1028 RECORD(TYPE_CONSTANT_ARRAY);
1029 RECORD(TYPE_INCOMPLETE_ARRAY);
1030 RECORD(TYPE_VARIABLE_ARRAY);
1033 RECORD(TYPE_FUNCTION_NO_PROTO);
1034 RECORD(TYPE_FUNCTION_PROTO);
1036 RECORD(TYPE_TYPEOF_EXPR);
1040 RECORD(TYPE_OBJC_INTERFACE);
1041 RECORD(TYPE_OBJC_OBJECT_POINTER);
1044 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
1045 RECORD(TYPE_UNRESOLVED_USING);
1046 RECORD(TYPE_INJECTED_CLASS_NAME);
1047 RECORD(TYPE_OBJC_OBJECT);
1048 RECORD(TYPE_TEMPLATE_TYPE_PARM);
1049 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
1050 RECORD(TYPE_DEPENDENT_NAME);
1051 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
1052 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
1054 RECORD(TYPE_MACRO_QUALIFIED);
1055 RECORD(TYPE_PACK_EXPANSION);
1057 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
1059 RECORD(TYPE_UNARY_TRANSFORM);
1063 RECORD(TYPE_OBJC_TYPE_PARAM);
1141 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
1147 BLOCK(EXTENSION_BLOCK);
1150 BLOCK(UNHASHED_CONTROL_BLOCK);
1171 return Changed | llvm::sys::path::remove_dots(
Path);
1186 assert(
Filename &&
"No file name to adjust?");
1188 if (BaseDir.empty())
1193 for (;
Filename[Pos] && Pos < BaseDir.size(); ++Pos)
1203 if (!llvm::sys::path::is_separator(
Filename[Pos])) {
1204 if (!llvm::sys::path::is_separator(BaseDir.back()))
1221std::pair<ASTFileSignature, ASTFileSignature>
1222ASTWriter::createSignature()
const {
1223 StringRef AllBytes(Buffer.data(), Buffer.size());
1226 Hasher.update(AllBytes.slice(ASTBlockRange.first, ASTBlockRange.second));
1231 Hasher.update(AllBytes.slice(0, UnhashedControlBlockRange.first));
1234 AllBytes.slice(UnhashedControlBlockRange.second, ASTBlockRange.first));
1236 Hasher.update(AllBytes.slice(ASTBlockRange.second, StringRef::npos));
1239 return std::make_pair(ASTBlockHash, Signature);
1244 Hasher.update(StringRef(Buffer.data(), Buffer.size()));
1246 assert(WritingModule);
1251 for (
auto [ExportImported, _] : WritingModule->
Exports)
1252 Hasher.update(ExportImported->Signature);
1276 for (
Module *M : TouchedTopLevelModules)
1284 for (uint8_t Byte : S) {
1285 Stream.BackpatchByte(BitNo, Byte);
1297 if (!WritingModule ||
1304 std::tie(ASTBlockHash, Signature) = createSignature();
1312void ASTWriter::writeUnhashedControlBlock(
Preprocessor &PP) {
1313 using namespace llvm;
1316 Stream.FlushToWord();
1317 UnhashedControlBlockRange.first = Stream.GetCurrentBitNo() >> 3;
1340 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1342 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1343 unsigned ASTBlockHashAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1346 Stream.EmitRecordWithBlob(ASTBlockHashAbbrev,
Record, Blob);
1347 ASTBlockHashOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1351 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1352 Abbrev->Add(BitCodeAbbrevOp(
SIGNATURE));
1353 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1354 unsigned SignatureAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1357 Stream.EmitRecordWithBlob(SignatureAbbrev,
Record, Blob);
1358 SignatureOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1367 if (!HSOpts.ModulesSkipDiagnosticOptions) {
1368#define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1369#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1370 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1371#include "clang/Basic/DiagnosticOptions.def"
1373 for (
unsigned I = 0, N = DiagOpts.
Warnings.size(); I != N; ++I)
1376 for (
unsigned I = 0, N = DiagOpts.
Remarks.size(); I != N; ++I)
1385 if (!HSOpts.ModulesSkipHeaderSearchPaths) {
1387 Record.push_back(HSOpts.UserEntries.size());
1388 for (
unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
1391 Record.push_back(
static_cast<unsigned>(Entry.
Group));
1397 Record.push_back(HSOpts.SystemHeaderPrefixes.size());
1398 for (
unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
1400 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
1404 Record.push_back(HSOpts.VFSOverlayFiles.size());
1405 for (StringRef VFSOverlayFile : HSOpts.VFSOverlayFiles)
1411 if (!HSOpts.ModulesSkipPragmaDiagnosticMappings)
1412 WritePragmaDiagnosticMappings(Diags, WritingModule);
1417 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1419 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1420 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1421 unsigned HSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1423 HSEntryUsage.size()};
1424 Stream.EmitRecordWithBlob(HSUsageAbbrevCode,
Record,
bytes(HSEntryUsage));
1430 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1431 Abbrev->Add(BitCodeAbbrevOp(
VFS_USAGE));
1432 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1433 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1434 unsigned VFSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1436 Stream.EmitRecordWithBlob(VFSUsageAbbrevCode,
Record,
bytes(VFSUsage));
1441 UnhashedControlBlockRange.second = Stream.GetCurrentBitNo() >> 3;
1445void ASTWriter::WriteControlBlock(
Preprocessor &PP, StringRef isysroot) {
1446 using namespace llvm;
1455 auto MetadataAbbrev = std::make_shared<BitCodeAbbrev>();
1456 MetadataAbbrev->Add(BitCodeAbbrevOp(
METADATA));
1457 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1458 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1459 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1460 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1461 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1463 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1464 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1465 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1466 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1467 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));
1468 assert((!WritingModule || isysroot.empty()) &&
1469 "writing module as a relocatable PCH?");
1474 CLANG_VERSION_MAJOR,
1475 CLANG_VERSION_MINOR,
1479 ASTHasCompilerErrors};
1480 Stream.EmitRecordWithBlob(MetadataAbbrevCode,
Record,
1484 if (WritingModule) {
1486 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1488 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1489 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1491 Stream.EmitRecordWithBlob(AbbrevCode,
Record, WritingModule->
Name);
1494 if (WritingModule && WritingModule->
Directory) {
1499 BaseDir.assign(CWD->getName());
1514 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1516 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1517 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1520 Stream.EmitRecordWithBlob(AbbrevCode,
Record, BaseDir);
1524 BaseDirectory.assign(BaseDir.begin(), BaseDir.end());
1525 }
else if (!isysroot.empty()) {
1527 BaseDirectory = std::string(isysroot);
1536 ? Map.getModuleMapFileForUniquing(WritingModule)
1537 ->getNameAsRequested()
1542 if (
auto *AdditionalModMaps =
1543 Map.getAdditionalModuleMapFiles(WritingModule)) {
1544 Record.push_back(AdditionalModMaps->size());
1546 AdditionalModMaps->end());
1561 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1562 Abbrev->Add(BitCodeAbbrevOp(
IMPORT));
1563 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1564 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1565 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1566 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1567 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1568 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1569 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1570 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1571 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1577 if (!M.isDirectlyImported())
1587 Record.push_back(M.StandardCXXModule);
1591 if (M.StandardCXXModule) {
1606 Stream.EmitRecordWithBlob(AbbrevCode,
Record, Blob);
1616#define LANGOPT(Name, Bits, Default, Description) \
1617 Record.push_back(LangOpts.Name);
1618#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1619 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1620#include "clang/Basic/LangOptions.def"
1621#define SANITIZER(NAME, ID) \
1622 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID));
1623#include "clang/Basic/Sanitizers.def"
1663 for (
unsigned I = 0, N = TargetOpts.
Features.size(); I != N; ++I) {
1703 bool WriteMacros = !SkipMacros;
1704 Record.push_back(WriteMacros);
1708 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
1716 for (
unsigned I = 0, N = PPOpts.
Includes.size(); I != N; ++I)
1721 for (
unsigned I = 0, N = PPOpts.
MacroIncludes.size(); I != N; ++I)
1737 auto FileAbbrev = std::make_shared<BitCodeAbbrev>();
1739 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1740 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1741 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));
1760struct InputFileEntry {
1764 bool BufferOverridden;
1779 assert(IncludeFID.
isValid() &&
"IncludeLoc in invalid file");
1780 if (!IsSLocAffecting[IncludeFID.ID])
1788 using namespace llvm;
1793 auto IFAbbrev = std::make_shared<BitCodeAbbrev>();
1795 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1796 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12));
1797 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
1798 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1799 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1800 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1801 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1802 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
1803 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1804 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));
1807 auto IFHAbbrev = std::make_shared<BitCodeAbbrev>();
1809 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1810 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1811 unsigned IFHAbbrevCode = Stream.EmitAbbrev(std::move(IFHAbbrev));
1813 uint64_t InputFilesOffsetBase = Stream.GetCurrentBitNo();
1816 std::vector<InputFileEntry> UserFiles;
1817 std::vector<InputFileEntry> SystemFiles;
1821 assert(&SourceMgr.
getSLocEntry(FileID::get(I)) == SLoc);
1828 if (!
Cache->OrigEntry)
1832 if (!IsSLocFileEntryAffecting[I])
1835 InputFileEntry Entry(*
Cache->OrigEntry);
1836 Entry.IsSystemFile =
isSystem(
File.getFileCharacteristic());
1837 Entry.IsTransient =
Cache->IsTransient;
1838 Entry.BufferOverridden =
Cache->BufferOverridden;
1841 Entry.IsTopLevel = IncludeFileID.
isInvalid() || IncludeFileID.ID < 0 ||
1842 !IsSLocFileEntryAffecting[IncludeFileID.ID];
1849 auto MemBuff =
Cache->getBufferIfLoaded();
1851 ContentHash = xxh3_64bits(MemBuff->getBuffer());
1854 << Entry.File.getName();
1856 Entry.ContentHash[0] =
uint32_t(ContentHash);
1857 Entry.ContentHash[1] =
uint32_t(ContentHash >> 32);
1858 if (Entry.IsSystemFile)
1859 SystemFiles.push_back(Entry);
1861 UserFiles.push_back(Entry);
1865 auto SortedFiles = llvm::concat<InputFileEntry>(std::move(UserFiles),
1866 std::move(SystemFiles));
1868 unsigned UserFilesNum = 0;
1870 std::vector<uint64_t> InputFileOffsets;
1871 for (
const auto &Entry : SortedFiles) {
1872 uint32_t &InputFileID = InputFileIDs[Entry.File];
1873 if (InputFileID != 0)
1877 InputFileOffsets.push_back(Stream.GetCurrentBitNo() - InputFilesOffsetBase);
1879 InputFileID = InputFileOffsets.size();
1881 if (!Entry.IsSystemFile)
1893 if (Name == NameAsRequested)
1896 RecordData::value_type
Record[] = {
1898 InputFileOffsets.size(),
1901 Entry.BufferOverridden,
1905 NameAsRequested.size()};
1907 Stream.EmitRecordWithBlob(IFAbbrevCode,
Record,
1908 (NameAsRequested + Name).str());
1914 Entry.ContentHash[1]};
1915 Stream.EmitRecordWithAbbrev(IFHAbbrevCode,
Record);
1922 auto OffsetsAbbrev = std::make_shared<BitCodeAbbrev>();
1924 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1925 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1927 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1928 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));
1932 InputFileOffsets.size(), UserFilesNum};
1933 Stream.EmitRecordWithBlob(OffsetsAbbrevCode,
Record,
bytes(InputFileOffsets));
1943 using namespace llvm;
1945 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1947 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1948 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1949 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1950 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1952 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1953 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1954 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24));
1955 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1956 return Stream.EmitAbbrev(std::move(Abbrev));
1962 using namespace llvm;
1964 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1966 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1967 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1968 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1969 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1970 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1971 return Stream.EmitAbbrev(std::move(Abbrev));
1978 using namespace llvm;
1980 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1984 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1985 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1986 return Stream.EmitAbbrev(std::move(Abbrev));
1992 using namespace llvm;
1994 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1996 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1997 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1998 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1999 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2000 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2001 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2002 return Stream.EmitAbbrev(std::move(Abbrev));
2007static std::pair<unsigned, unsigned>
2009 llvm::encodeULEB128(KeyLen, Out);
2010 llvm::encodeULEB128(DataLen, Out);
2011 return std::make_pair(KeyLen, DataLen);
2017 class HeaderFileInfoTrait {
2021 HeaderFileInfoTrait(
ASTWriter &Writer) : Writer(Writer) {}
2028 using key_type_ref =
const key_type &;
2030 using UnresolvedModule =
2031 llvm::PointerIntPair<Module *, 2, ModuleMap::ModuleHeaderRole>;
2037 : HFI(HFI), AlreadyIncluded(AlreadyIncluded),
2041 bool AlreadyIncluded;
2045 using data_type_ref =
const data_type &;
2054 uint8_t buf[
sizeof(key.Size) +
sizeof(key.ModTime)];
2055 memcpy(buf, &key.Size,
sizeof(key.Size));
2056 memcpy(buf +
sizeof(key.Size), &key.ModTime,
sizeof(key.ModTime));
2057 return llvm::xxh3_64bits(buf);
2060 std::pair<unsigned, unsigned>
2061 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref
Data) {
2062 unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
2064 for (
auto ModInfo :
Data.KnownHeaders)
2067 if (
Data.Unresolved.getPointer())
2072 void EmitKey(raw_ostream& Out, key_type_ref key,
unsigned KeyLen) {
2073 using namespace llvm::support;
2075 endian::Writer
LE(Out, llvm::endianness::little);
2080 Out.write(key.Filename.data(), KeyLen);
2083 void EmitData(raw_ostream &Out, key_type_ref key,
2084 data_type_ref
Data,
unsigned DataLen) {
2085 using namespace llvm::support;
2087 endian::Writer
LE(Out, llvm::endianness::little);
2088 uint64_t Start = Out.tell(); (void)Start;
2090 unsigned char Flags = (
Data.AlreadyIncluded << 6)
2091 | (
Data.HFI.isImport << 5)
2093 Data.HFI.isPragmaOnce << 4)
2094 | (
Data.HFI.DirInfo << 1);
2095 LE.write<uint8_t>(Flags);
2097 if (
Data.HFI.LazyControllingMacro.isID())
2106 assert((
Value >> 3) == ModID &&
"overflow in header module info");
2111 for (
auto ModInfo :
Data.KnownHeaders)
2112 EmitModule(ModInfo.getModule(), ModInfo.getRole());
2113 if (
Data.Unresolved.getPointer())
2114 EmitModule(
Data.Unresolved.getPointer(),
Data.Unresolved.getInt());
2116 assert(Out.tell() - Start == DataLen &&
"Wrong data length");
2125void ASTWriter::WriteHeaderSearch(
const HeaderSearch &HS) {
2126 HeaderFileInfoTrait GeneratorTrait(*
this);
2127 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait>
Generator;
2129 unsigned NumHeaderSearchEntries = 0;
2136 if (WritingModule) {
2138 while (!Worklist.empty()) {
2139 Module *M = Worklist.pop_back_val();
2156 if (!
U.Size || (!
U.ModTime && IncludeTimestamps)) {
2157 PP->
Diag(
U.FileNameLoc, diag::err_module_no_size_mtime_for_header)
2165 llvm::sys::path::append(
Filename,
U.FileName);
2168 StringRef FilenameDup = strdup(
Filename.c_str());
2169 SavedStrings.push_back(FilenameDup.data());
2171 HeaderFileInfoTrait::key_type Key = {
2172 FilenameDup, *
U.Size, IncludeTimestamps ? *
U.ModTime : 0};
2173 HeaderFileInfoTrait::data_type
Data = {
2178 ++NumHeaderSearchEntries;
2181 Worklist.append(SubmodulesRange.begin(), SubmodulesRange.end());
2191 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
2210 Filename = StringRef(strdup(FilenameTmp.c_str()));
2211 SavedStrings.push_back(
Filename.data());
2216 HeaderFileInfoTrait::key_type Key = {
2219 HeaderFileInfoTrait::data_type
Data = {
2223 ++NumHeaderSearchEntries;
2230 using namespace llvm::support;
2232 llvm::raw_svector_ostream Out(TableData);
2234 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
2235 BucketOffset =
Generator.Emit(Out, GeneratorTrait);
2239 using namespace llvm;
2241 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2243 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2244 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2245 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2246 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2247 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2251 NumHeaderSearchEntries, TableData.size()};
2252 Stream.EmitRecordWithBlob(TableAbbrev,
Record, TableData);
2255 for (
unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
2256 free(
const_cast<char *
>(SavedStrings[I]));
2259static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
2260 unsigned SLocBufferBlobCompressedAbbrv,
2261 unsigned SLocBufferBlobAbbrv) {
2262 using RecordDataType = ASTWriter::RecordData::value_type;
2267 if (llvm::compression::zstd::isAvailable()) {
2268 llvm::compression::zstd::compress(
2269 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer, 9);
2271 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2272 llvm::toStringRef(CompressedBuffer));
2275 if (llvm::compression::zlib::isAvailable()) {
2276 llvm::compression::zlib::compress(
2277 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer);
2279 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2280 llvm::toStringRef(CompressedBuffer));
2285 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv,
Record, Blob);
2296void ASTWriter::WriteSourceManagerBlock(
SourceManager &SourceMgr) {
2301 const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo();
2307 unsigned SLocBufferBlobCompressedAbbrv =
2313 std::vector<uint32_t> SLocEntryOffsets;
2314 uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
2320 FileID FID = FileID::get(I);
2324 uint64_t Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;
2325 assert((Offset >> 32) == 0 &&
"SLocEntry offset too large");
2331 if (
Cache->OrigEntry) {
2344 if (!IsSLocAffecting[I])
2346 SLocEntryOffsets.push_back(Offset);
2350 Record.push_back(
File.getFileCharacteristic());
2353 bool EmitBlob =
false;
2356 "Writing to AST an overridden file is not supported");
2359 assert(InputFileIDs[*Content->
OrigEntry] != 0 &&
"Missed file entry");
2362 Record.push_back(getAdjustedNumCreatedFIDs(FID));
2364 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
2365 if (FDI != FileDeclIDs.end()) {
2366 Record.push_back(FDI->second->FirstDeclIndex);
2367 Record.push_back(FDI->second->DeclIDs.size());
2373 Stream.EmitRecordWithAbbrev(SLocFileAbbrv,
Record);
2384 std::optional<llvm::MemoryBufferRef> Buffer = Content->
getBufferOrNone(
2386 StringRef Name = Buffer ? Buffer->getBufferIdentifier() :
"";
2387 Stream.EmitRecordWithBlob(SLocBufferAbbrv,
Record,
2388 StringRef(Name.data(), Name.size() + 1));
2395 std::optional<llvm::MemoryBufferRef> Buffer = Content->
getBufferOrNone(
2398 Buffer = llvm::MemoryBufferRef(
"<<<INVALID BUFFER>>>",
"");
2399 StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
2400 emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
2401 SLocBufferBlobAbbrv);
2406 SLocEntryOffsets.push_back(Offset);
2422 Record.push_back(getAdjustedOffset(NextOffset - SLoc->
getOffset()) - 1);
2423 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv,
Record);
2429 if (SLocEntryOffsets.empty())
2434 using namespace llvm;
2436 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2438 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2439 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2440 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2441 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2442 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2444 RecordData::value_type
Record[] = {
2447 SLocEntryOffsetsBase - SourceManagerBlockOffset};
2448 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev,
Record,
2449 bytes(SLocEntryOffsets));
2460 llvm::DenseMap<int, int> FilenameMap;
2461 FilenameMap[-1] = -1;
2462 for (
const auto &L : LineTable) {
2465 for (
auto &LE : L.second) {
2466 if (FilenameMap.insert(std::make_pair(
LE.FilenameID,
2467 FilenameMap.size() - 1)).second)
2474 for (
const auto &L : LineTable) {
2482 Record.push_back(L.second.size());
2483 for (
const auto &LE : L.second) {
2486 Record.push_back(FilenameMap[
LE.FilenameID]);
2487 Record.push_back((
unsigned)
LE.FileKind);
2488 Record.push_back(
LE.IncludeOffset);
2503 if (MI->isBuiltinMacro())
2519void ASTWriter::WritePreprocessor(
const Preprocessor &PP,
bool IsModule) {
2520 uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo();
2524 WritePreprocessorDetail(*PPRec, MacroOffsetsBase);
2539 if (AssumeNonNullLoc.
isValid()) {
2553 Record.push_back(SkipInfo->FoundNonSkipPortion);
2554 Record.push_back(SkipInfo->FoundElse);
2561 Record.push_back(Cond.WasSkipping);
2562 Record.push_back(Cond.FoundNonSkip);
2563 Record.push_back(Cond.FoundElse);
2593 if (
Id.second->hadMacroDefinition() &&
2594 (!
Id.second->isFromAST() ||
2595 Id.second->hasChangedSinceDeserialization()))
2596 MacroIdentifiers.push_back(
Id.second);
2599 llvm::sort(MacroIdentifiers, llvm::deref<std::less<>>());
2605 uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2606 assert((StartOffset >> 32) == 0 &&
"Macro identifiers offset too large");
2609 bool EmittedModuleMacros =
false;
2626 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2628 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2629 Record.push_back(VisMD->isPublic());
2631 ModuleMacroRecord.push_back(getSubmoduleID(WritingModule));
2634 ModuleMacroRecord.clear();
2635 EmittedModuleMacros =
true;
2645 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2647 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2648 Record.push_back(VisMD->isPublic());
2655 llvm::DenseMap<ModuleMacro *, unsigned> Visits;
2656 while (!Worklist.empty()) {
2657 auto *
Macro = Worklist.pop_back_val();
2660 ModuleMacroRecord.push_back(getSubmoduleID(
Macro->getOwningModule()));
2662 for (
auto *M :
Macro->overrides())
2663 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));
2666 ModuleMacroRecord.clear();
2669 for (
auto *M :
Macro->overrides())
2670 if (++Visits[M] == M->getNumOverridingMacros())
2671 Worklist.push_back(M);
2673 EmittedModuleMacros =
true;
2676 if (
Record.empty() && !EmittedModuleMacros)
2679 IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2690 std::vector<uint32_t> MacroOffsets;
2692 for (
unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2697 if (ID < FirstMacroID) {
2698 assert(0 &&
"Loaded MacroInfo entered MacroInfosToEmit ?");
2703 unsigned Index =
ID - FirstMacroID;
2704 if (Index >= MacroOffsets.size())
2705 MacroOffsets.resize(Index + 1);
2707 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2708 assert((Offset >> 32) == 0 &&
"Macro offset too large");
2709 MacroOffsets[Index] = Offset;
2736 Stream.EmitRecord(Code,
Record);
2740 for (
unsigned TokNo = 0, e = MI->
getNumTokens(); TokNo != e; ++TokNo) {
2755 using namespace llvm;
2757 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2759 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2760 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2761 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2762 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2764 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2768 MacroOffsetsBase - ASTBlockStartOffset};
2769 Stream.EmitRecordWithBlob(MacroOffsetAbbrev,
Record,
bytes(MacroOffsets));
2774 uint64_t MacroOffsetsBase) {
2784 unsigned NumPreprocessingRecords = 0;
2785 using namespace llvm;
2788 unsigned InclusionAbbrev = 0;
2790 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2792 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2793 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2794 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
2795 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2796 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2797 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2800 unsigned FirstPreprocessorEntityID
2801 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2803 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
2808 (void)++
E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
2811 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2812 assert((Offset >> 32) == 0 &&
"Preprocessed entity offset too large");
2813 SourceRange R = getAdjustedRange((*E)->getSourceRange());
2814 PreprocessedEntityOffsets.emplace_back(
2818 if (
auto *MD = dyn_cast<MacroDefinitionRecord>(*
E)) {
2820 MacroDefinitions[MD] = NextPreprocessorEntityID;
2827 if (
auto *ME = dyn_cast<MacroExpansion>(*
E)) {
2828 Record.push_back(ME->isBuiltinMacro());
2829 if (ME->isBuiltinMacro())
2832 Record.push_back(MacroDefinitions[ME->getDefinition()]);
2837 if (
auto *ID = dyn_cast<InclusionDirective>(*
E)) {
2839 Record.push_back(
ID->getFileName().size());
2840 Record.push_back(
ID->wasInQuotes());
2841 Record.push_back(
static_cast<unsigned>(
ID->getKind()));
2842 Record.push_back(
ID->importedModule());
2844 Buffer +=
ID->getFileName();
2848 Buffer +=
ID->getFile()->getName();
2849 Stream.EmitRecordWithBlob(InclusionAbbrev,
Record, Buffer);
2853 llvm_unreachable(
"Unhandled PreprocessedEntity in ASTWriter");
2858 if (NumPreprocessingRecords > 0) {
2859 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2862 using namespace llvm;
2864 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2866 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2867 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2868 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2871 FirstPreprocessorEntityID -
2873 Stream.EmitRecordWithBlob(PPEOffsetAbbrev,
Record,
2874 bytes(PreprocessedEntityOffsets));
2879 if (SkippedRanges.size() > 0) {
2880 std::vector<PPSkippedRange> SerializedSkippedRanges;
2881 SerializedSkippedRanges.reserve(SkippedRanges.size());
2882 for (
auto const&
Range : SkippedRanges)
2883 SerializedSkippedRanges.emplace_back(
2887 using namespace llvm;
2888 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2890 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2891 unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2895 Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev,
Record,
2896 bytes(SerializedSkippedRanges));
2904 auto Known = SubmoduleIDs.find(Mod);
2905 if (Known != SubmoduleIDs.end())
2906 return Known->second;
2909 if (Top != WritingModule &&
2911 !Top->fullModuleNameIs(StringRef(
getLangOpts().CurrentModule))))
2914 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2917unsigned ASTWriter::getSubmoduleID(
Module *Mod) {
2930 unsigned ChildModules = 0;
2934 return ChildModules + 1;
2937void ASTWriter::WriteSubmodules(
Module *WritingModule,
ASTContext *Context) {
2942 using namespace llvm;
2944 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2946 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2947 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2948 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));
2949 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
2950 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));
2951 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2952 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2953 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2954 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2955 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2956 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2957 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2958 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2959 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2960 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2961 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2962 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2964 Abbrev = std::make_shared<BitCodeAbbrev>();
2966 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2967 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2969 Abbrev = std::make_shared<BitCodeAbbrev>();
2971 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2972 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2974 Abbrev = std::make_shared<BitCodeAbbrev>();
2976 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2977 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2979 Abbrev = std::make_shared<BitCodeAbbrev>();
2981 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2982 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2984 Abbrev = std::make_shared<BitCodeAbbrev>();
2986 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2987 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2988 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2990 Abbrev = std::make_shared<BitCodeAbbrev>();
2992 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2993 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2995 Abbrev = std::make_shared<BitCodeAbbrev>();
2997 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2998 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3000 Abbrev = std::make_shared<BitCodeAbbrev>();
3002 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3003 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3005 Abbrev = std::make_shared<BitCodeAbbrev>();
3007 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3008 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3010 Abbrev = std::make_shared<BitCodeAbbrev>();
3012 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
3013 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3014 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3016 Abbrev = std::make_shared<BitCodeAbbrev>();
3018 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3019 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3021 Abbrev = std::make_shared<BitCodeAbbrev>();
3023 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
3024 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3025 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3027 Abbrev = std::make_shared<BitCodeAbbrev>();
3029 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3030 unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3033 RecordData::value_type
Record[] = {
3039 std::queue<Module *> Q;
3040 Q.push(WritingModule);
3041 while (!Q.empty()) {
3044 unsigned ID = getSubmoduleID(Mod);
3048 assert(SubmoduleIDs[Mod->
Parent] &&
"Submodule parent not written?");
3049 ParentID = SubmoduleIDs[Mod->
Parent];
3056 FileID UnadjustedInferredFID;
3059 int InferredFID = getAdjustedFileID(UnadjustedInferredFID).getOpaqueValue();
3066 (RecordData::value_type)Mod->
Kind,
3068 (RecordData::value_type)InferredFID,
3079 Stream.EmitRecordWithBlob(DefinitionAbbrev,
Record, Mod->
Name);
3085 Stream.EmitRecordWithBlob(RequiresAbbrev,
Record, R.FeatureName);
3089 if (std::optional<Module::Header> UmbrellaHeader =
3092 Stream.EmitRecordWithBlob(UmbrellaAbbrev,
Record,
3093 UmbrellaHeader->NameAsWritten);
3094 }
else if (std::optional<Module::DirectoryName> UmbrellaDir =
3097 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev,
Record,
3098 UmbrellaDir->NameAsWritten);
3103 unsigned RecordKind;
3114 for (
const auto &HL : HeaderLists) {
3115 RecordData::value_type
Record[] = {HL.RecordKind};
3116 for (
const auto &H : Mod->
getHeaders(HL.HeaderKind))
3117 Stream.EmitRecordWithBlob(HL.Abbrev,
Record, H.NameAsWritten);
3126 Stream.EmitRecordWithBlob(TopHeaderAbbrev,
Record, HeaderName);
3134 Record.push_back(getSubmoduleID(I));
3142 Record.push_back(getSubmoduleID(I));
3149 for (
const auto &
E : Mod->
Exports) {
3152 Record.push_back(getSubmoduleID(
E.getPointer()));
3168 Stream.EmitRecordWithBlob(LinkLibraryAbbrev,
Record, LL.Library);
3176 getSubmoduleID(
C.Other)};
3177 Stream.EmitRecordWithBlob(ConflictAbbrev,
Record,
C.Message);
3183 Stream.EmitRecordWithBlob(ConfigMacroAbbrev,
Record, CM);
3210 assert((NextSubmoduleID - FirstSubmoduleID ==
3212 "Wrong # of submodules; found a reference to a non-local, "
3213 "non-imported submodule?");
3218 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
3220 unsigned CurrID = 0;
3223 auto EncodeDiagStateFlags =
3224 [](
const DiagnosticsEngine::DiagState *DS) ->
unsigned {
3227 {(
unsigned)DS->IgnoreAllWarnings, (
unsigned)DS->EnableAllWarnings,
3228 (
unsigned)DS->WarningsAsErrors, (
unsigned)DS->ErrorsAsFatal,
3229 (
unsigned)DS->SuppressSystemWarnings})
3234 unsigned Flags = EncodeDiagStateFlags(
Diag.DiagStatesByLoc.FirstDiagState);
3237 auto AddDiagState = [&](
const DiagnosticsEngine::DiagState *State,
3238 bool IncludeNonPragmaStates) {
3241 assert(Flags == EncodeDiagStateFlags(State) &&
3242 "diag state flags vary in single AST file");
3246 assert(!IncludeNonPragmaStates ||
3247 State ==
Diag.DiagStatesByLoc.FirstDiagState);
3249 unsigned &DiagStateID = DiagStateIDMap[State];
3250 Record.push_back(DiagStateID);
3252 if (DiagStateID == 0) {
3253 DiagStateID = ++CurrID;
3257 auto SizeIdx =
Record.size();
3259 for (
const auto &I : *State) {
3261 if (!I.second.isPragma() && !IncludeNonPragmaStates)
3265 if (!I.second.isPragma() &&
3268 Mappings.push_back(I);
3272 llvm::sort(Mappings, llvm::less_first());
3274 for (
const auto &I : Mappings) {
3275 Record.push_back(I.first);
3276 Record.push_back(I.second.serialize());
3283 AddDiagState(
Diag.DiagStatesByLoc.FirstDiagState, isModule);
3286 auto NumLocationsIdx =
Record.size();
3290 unsigned NumLocations = 0;
3291 for (
auto &FileIDAndFile :
Diag.DiagStatesByLoc.Files) {
3292 if (!FileIDAndFile.first.isValid() ||
3293 !FileIDAndFile.second.HasLocalTransitions)
3299 Record.push_back(FileIDAndFile.second.StateTransitions.size());
3300 for (
auto &StatePoint : FileIDAndFile.second.StateTransitions) {
3301 Record.push_back(getAdjustedOffset(StatePoint.Offset));
3302 AddDiagState(StatePoint.State,
false);
3307 Record[NumLocationsIdx] = NumLocations;
3316 AddDiagState(
Diag.DiagStatesByLoc.CurDiagState,
false);
3329 IdxRef =
TypeIdx(0, NextTypeID++);
3333 assert(Idx.
getValue() >= FirstTypeID &&
"Writing predefined type");
3337 ASTTypeWriter(Context, *
this).write(
T) - DeclTypesBlockStartOffset;
3341 if (TypeOffsets.size() == Index)
3342 TypeOffsets.emplace_back(Offset);
3343 else if (TypeOffsets.size() < Index) {
3344 TypeOffsets.resize(Index + 1);
3345 TypeOffsets[Index].set(Offset);
3347 llvm_unreachable(
"Types emitted in wrong order");
3356 auto *ND = dyn_cast<NamedDecl>(
D);
3380 uint64_t Offset = Stream.GetCurrentBitNo();
3382 for (
const auto *
D : DC->
decls()) {
3395 KindDeclPairs.push_back(
D->
getKind());
3396 KindDeclPairs.push_back(
GetDeclRef(
D).getRawValue());
3399 ++NumLexicalDeclContexts;
3401 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev,
Record,
3402 bytes(KindDeclPairs));
3406void ASTWriter::WriteTypeDeclOffsets() {
3407 using namespace llvm;
3410 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3412 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3413 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3414 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3417 Stream.EmitRecordWithBlob(TypeOffsetAbbrev,
Record,
bytes(TypeOffsets));
3421 Abbrev = std::make_shared<BitCodeAbbrev>();
3423 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3424 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3425 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3428 Stream.EmitRecordWithBlob(DeclOffsetAbbrev,
Record,
bytes(DeclOffsets));
3432void ASTWriter::WriteFileDeclIDsMap() {
3433 using namespace llvm;
3436 SortedFileDeclIDs.reserve(FileDeclIDs.size());
3437 for (
const auto &
P : FileDeclIDs)
3438 SortedFileDeclIDs.push_back(std::make_pair(
P.first,
P.second.get()));
3439 llvm::sort(SortedFileDeclIDs, llvm::less_first());
3443 for (
auto &FileDeclEntry : SortedFileDeclIDs) {
3444 DeclIDInFileInfo &Info = *FileDeclEntry.second;
3445 Info.FirstDeclIndex = FileGroupedDeclIDs.size();
3446 llvm::stable_sort(Info.DeclIDs);
3447 for (
auto &LocDeclEntry : Info.DeclIDs)
3448 FileGroupedDeclIDs.push_back(LocDeclEntry.second.getRawValue());
3451 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3453 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3454 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3455 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
3457 FileGroupedDeclIDs.size()};
3458 Stream.EmitRecordWithBlob(AbbrevCode,
Record,
bytes(FileGroupedDeclIDs));
3461void ASTWriter::WriteComments(
ASTContext &Context) {
3463 auto _ = llvm::make_scope_exit([
this] { Stream.ExitBlock(); });
3474 for (
const auto &FO : Context.
Comments.OrderedComments) {
3475 for (
const auto &OC : FO.second) {
3494class ASTMethodPoolTrait {
3499 using key_type_ref = key_type;
3505 using data_type_ref =
const data_type &;
3510 explicit ASTMethodPoolTrait(
ASTWriter &Writer) : Writer(Writer) {}
3516 std::pair<unsigned, unsigned>
3517 EmitKeyDataLength(raw_ostream& Out,
Selector Sel,
3518 data_type_ref Methods) {
3522 unsigned DataLen = 4 + 2 + 2;
3525 if (ShouldWriteMethodListNode(Method))
3526 DataLen +=
sizeof(
DeclID);
3529 if (ShouldWriteMethodListNode(Method))
3530 DataLen +=
sizeof(
DeclID);
3534 void EmitKey(raw_ostream& Out,
Selector Sel,
unsigned) {
3535 using namespace llvm::support;
3537 endian::Writer
LE(Out, llvm::endianness::little);
3539 assert((Start >> 32) == 0 &&
"Selector key offset too large");
3542 LE.write<uint16_t>(N);
3545 for (
unsigned I = 0; I != N; ++I)
3550 void EmitData(raw_ostream& Out, key_type_ref,
3551 data_type_ref Methods,
unsigned DataLen) {
3552 using namespace llvm::support;
3554 endian::Writer
LE(Out, llvm::endianness::little);
3555 uint64_t Start = Out.tell(); (void)Start;
3557 unsigned NumInstanceMethods = 0;
3560 if (ShouldWriteMethodListNode(Method))
3561 ++NumInstanceMethods;
3563 unsigned NumFactoryMethods = 0;
3566 if (ShouldWriteMethodListNode(Method))
3567 ++NumFactoryMethods;
3569 unsigned InstanceBits = Methods.Instance.getBits();
3570 assert(InstanceBits < 4);
3571 unsigned InstanceHasMoreThanOneDeclBit =
3572 Methods.Instance.hasMoreThanOneDecl();
3573 unsigned FullInstanceBits = (NumInstanceMethods << 3) |
3574 (InstanceHasMoreThanOneDeclBit << 2) |
3576 unsigned FactoryBits = Methods.Factory.getBits();
3577 assert(FactoryBits < 4);
3578 unsigned FactoryHasMoreThanOneDeclBit =
3579 Methods.Factory.hasMoreThanOneDecl();
3580 unsigned FullFactoryBits = (NumFactoryMethods << 3) |
3581 (FactoryHasMoreThanOneDeclBit << 2) |
3583 LE.write<uint16_t>(FullInstanceBits);
3584 LE.write<uint16_t>(FullFactoryBits);
3587 if (ShouldWriteMethodListNode(Method))
3591 if (ShouldWriteMethodListNode(Method))
3594 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
3599 return (
Node->getMethod() && !
Node->getMethod()->isFromASTFile());
3610void ASTWriter::WriteSelectors(
Sema &SemaRef) {
3611 using namespace llvm;
3616 unsigned NumTableEntries = 0;
3619 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait>
Generator;
3620 ASTMethodPoolTrait Trait(*
this);
3624 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
3625 for (
auto &SelectorAndID : SelectorIDs) {
3628 SemaObjC::GlobalMethodPool::iterator F =
3630 ASTMethodPoolTrait::data_type
Data = {
3636 Data.Instance = F->second.first;
3637 Data.Factory = F->second.second;
3641 if (Chain && ID < FirstSelectorID) {
3643 bool changed =
false;
3646 if (!M->getMethod()->isFromASTFile()) {
3654 if (!M->getMethod()->isFromASTFile()) {
3662 }
else if (
Data.Instance.getMethod() ||
Data.Factory.getMethod()) {
3673 using namespace llvm::support;
3675 ASTMethodPoolTrait Trait(*
this);
3676 llvm::raw_svector_ostream Out(MethodPool);
3678 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3679 BucketOffset =
Generator.Emit(Out, Trait);
3683 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3685 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3686 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3687 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3688 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3694 Stream.EmitRecordWithBlob(MethodPoolAbbrev,
Record, MethodPool);
3698 Abbrev = std::make_shared<BitCodeAbbrev>();
3700 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3701 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3702 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3703 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3707 RecordData::value_type
Record[] = {
3710 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev,
Record,
3711 bytes(SelectorOffsets));
3717void ASTWriter::WriteReferencedSelectorsPool(
Sema &SemaRef) {
3718 using namespace llvm;
3730 Selector Sel = SelectorAndLocation.first;
3732 Writer.AddSelectorRef(Sel);
3754 for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
3756 if (!Redecl->isFromASTFile()) {
3760 if (!Redecl->getDeclContext()->getRedeclContext()->Equals(
3763 return cast<NamedDecl>(Redecl);
3768 if (Redecl->getOwningModuleID() == 0)
3773 if (!
First->isFromASTFile())
3774 return cast<NamedDecl>(
First);
3784bool IsInterestingIdentifier(
const IdentifierInfo *II, uint64_t MacroOffset,
3785 bool IsModule,
bool IsCPlusPlus) {
3786 bool NeedDecls = !IsModule || !IsCPlusPlus;
3788 bool IsInteresting =
3792 if (MacroOffset || II->
isPoisoned() || (!IsModule && IsInteresting) ||
3803 bool IsCPlusPlus = Writer.
getLangOpts().CPlusPlus;
3804 return IsInterestingIdentifier(II, 0, IsModule, IsCPlusPlus);
3807class ASTIdentifierTableTrait {
3820 return IsInterestingIdentifier(II, MacroOffset, IsModule,
3826 using key_type_ref = key_type;
3829 using data_type_ref = data_type;
3837 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule),
3838 NeedDecls(!IsModule || !Writer.getLangOpts().
CPlusPlus),
3839 InterestingIdentifierOffsets(InterestingIdentifierOffsets) {}
3841 bool needDecls()
const {
return NeedDecls; }
3844 return llvm::djbHash(II->
getName());
3852 std::pair<unsigned, unsigned>
3862 if (InterestingIdentifierOffsets &&
3864 InterestingIdentifierOffsets->push_back(Out.tell());
3874 if (NeedDecls && IdResolver)
3875 DataLen += std::distance(IdResolver->
begin(II), IdResolver->
end()) *
3881 void EmitKey(raw_ostream &Out,
const IdentifierInfo *II,
unsigned KeyLen) {
3887 using namespace llvm::support;
3889 endian::Writer
LE(Out, llvm::endianness::little);
3899 assert((Bits & 0xffff) == Bits &&
"ObjCOrBuiltinID too big for ASTReader.");
3900 LE.write<uint16_t>(Bits);
3902 bool HadMacroDefinition = MacroOffset != 0;
3903 Bits = (Bits << 1) |
unsigned(HadMacroDefinition);
3905 Bits = (Bits << 1) |
unsigned(II->
isPoisoned());
3908 LE.write<uint16_t>(Bits);
3910 if (HadMacroDefinition)
3913 if (NeedDecls && IdResolver) {
3942 using namespace llvm;
3949 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait>
Generator;
3950 ASTIdentifierTableTrait Trait(*
this, PP, IdResolver, IsModule,
3951 IsModule ? &InterestingIdents :
nullptr);
3955 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
3956 for (
auto IdentIDPair : IdentifierIDs) {
3959 assert(II &&
"NULL identifier in identifier table");
3964 (Trait.needDecls() &&
3973 using namespace llvm::support;
3977 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3978 BucketOffset =
Generator.Emit(Out, Trait);
3982 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3984 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3985 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3986 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3994 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3996 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3997 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3998 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
4001 for (
unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
4002 assert(IdentifierOffsets[I] &&
"Missing identifier offset?");
4006 IdentifierOffsets.size()};
4007 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev,
Record,
4008 bytes(IdentifierOffsets));
4012 if (!InterestingIdents.empty())
4020 PendingEmittingVTables.push_back(RD);
4030class ASTDeclContextNameLookupTrait {
4036 using key_type_ref = key_type;
4039 using data_type = std::pair<unsigned, unsigned>;
4040 using data_type_ref =
const data_type &;
4045 explicit ASTDeclContextNameLookupTrait(
ASTWriter &Writer) : Writer(Writer) {}
4047 template<
typename Coll>
4048 data_type getData(
const Coll &Decls) {
4049 unsigned Start = DeclIDs.size();
4065 DeclIDs.push_back(Writer.
GetDeclRef(DeclForLocalLookup));
4067 return std::make_pair(Start, DeclIDs.size());
4071 unsigned Start = DeclIDs.size();
4076 return std::make_pair(Start, DeclIDs.size());
4079 static bool EqualKey(key_type_ref a, key_type_ref
b) {
4084 return Name.getHash();
4087 void EmitFileRef(raw_ostream &Out,
ModuleFile *F)
const {
4089 "have reference to loaded module file but no chain?");
4091 using namespace llvm::support;
4094 llvm::endianness::little);
4097 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
4099 data_type_ref Lookup) {
4100 unsigned KeyLen = 1;
4101 switch (Name.getKind()) {
4123 unsigned DataLen =
sizeof(
DeclID) * (Lookup.second - Lookup.first);
4129 using namespace llvm::support;
4131 endian::Writer
LE(Out, llvm::endianness::little);
4132 LE.write<uint8_t>(Name.getKind());
4133 switch (Name.getKind()) {
4146 "Invalid operator?");
4147 LE.write<uint8_t>(Name.getOperatorKind());
4156 llvm_unreachable(
"Invalid name kind?");
4159 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
4161 using namespace llvm::support;
4163 endian::Writer
LE(Out, llvm::endianness::little);
4164 uint64_t Start = Out.tell(); (void)Start;
4165 for (
unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
4167 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
4174class LazySpecializationInfoLookupTrait {
4180 using key_type_ref = key_type;
4183 using data_type = std::pair<unsigned, unsigned>;
4184 using data_type_ref =
const data_type &;
4189 explicit LazySpecializationInfoLookupTrait(
ASTWriter &Writer)
4192 template <
typename Col,
typename Col2>
4193 data_type getData(Col &&
C, Col2 &ExistingInfo) {
4194 unsigned Start = Specs.size();
4202 Specs.push_back(Info);
4203 return std::make_pair(Start, Specs.size());
4206 data_type ImportData(
4208 unsigned Start = Specs.size();
4209 for (
auto ID : FromReader)
4210 Specs.push_back(
ID);
4211 return std::make_pair(Start, Specs.size());
4214 static bool EqualKey(key_type_ref a, key_type_ref
b) {
return a ==
b; }
4216 hash_value_type
ComputeHash(key_type Name) {
return Name; }
4218 void EmitFileRef(raw_ostream &Out,
ModuleFile *F)
const {
4220 "have reference to loaded module file but no chain?");
4222 using namespace llvm::support;
4224 llvm::endianness::little);
4227 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
4229 data_type_ref Lookup) {
4231 unsigned KeyLen = 4;
4233 (Lookup.second - Lookup.first);
4238 void EmitKey(raw_ostream &Out, key_type HashValue,
unsigned) {
4239 using namespace llvm::support;
4241 endian::Writer
LE(Out, llvm::endianness::little);
4245 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
4247 using namespace llvm::support;
4249 endian::Writer
LE(Out, llvm::endianness::little);
4252 for (
unsigned I = Lookup.first, N = Lookup.second; I != N; ++I) {
4253 LE.write<
DeclID>(Specs[I].getRawValue());
4255 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
4259unsigned CalculateODRHashForSpecs(
const Decl *Spec) {
4261 if (
auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Spec))
4262 Args = CTSD->getTemplateArgs().asArray();
4263 else if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Spec))
4264 Args = VTSD->getTemplateArgs().asArray();
4265 else if (
auto *FD = dyn_cast<FunctionDecl>(Spec))
4266 Args = FD->getTemplateSpecializationArgs()->asArray();
4268 llvm_unreachable(
"New Specialization Kind?");
4274void ASTWriter::GenerateSpecializationInfoLookupTable(
4281 LazySpecializationInfoLookupTrait>
4283 LazySpecializationInfoLookupTrait Trait(*
this);
4285 llvm::DenseMap<unsigned, llvm::SmallVector<const NamedDecl *, 4>>
4291 auto Iter = SpecializationMaps.find(HashedValue);
4292 if (
Iter == SpecializationMaps.end())
4293 Iter = SpecializationMaps
4294 .try_emplace(HashedValue,
4305 for (
auto &[HashValue, Specs] : SpecializationMaps) {
4316 ExisitingSpecs = Lookups->Table.find(HashValue);
4318 Generator.insert(HashValue, Trait.getData(Specs, ExisitingSpecs), Trait);
4321 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table :
nullptr);
4324uint64_t ASTWriter::WriteSpecializationInfoLookupTable(
4329 GenerateSpecializationInfoLookupTable(
D, Specializations, LookupTable,
4332 uint64_t Offset = Stream.GetCurrentBitNo();
4333 RecordData::value_type
Record[] = {
static_cast<RecordData::value_type
>(
4335 Stream.EmitRecordWithBlob(IsPartial ? DeclPartialSpecializationsAbbrev
4336 : DeclSpecializationsAbbrev,
4344 return Result.hasExternalDecls() &&
4345 DC->hasNeedToReconcileExternalVisibleStorage();
4354 for (
auto *
D :
Result.getLookupResult()) {
4356 if (LocalD->isFromASTFile())
4374void ASTWriter::GenerateNameLookupTable(
4377 assert(!ConstDC->hasLazyLocalLexicalLookups() &&
4378 !ConstDC->hasLazyExternalLexicalLookups() &&
4379 "must call buildLookups first");
4387 ASTDeclContextNameLookupTrait>
Generator;
4388 ASTDeclContextNameLookupTrait Trait(*
this);
4400 auto &Name = Lookup.first;
4401 auto &
Result = Lookup.second;
4416 if ((GeneratingReducedBMI || isLookupResultExternal(
Result, DC)) &&
4434 if (Lookup.second.getLookupResult().empty())
4437 switch (Lookup.first.getNameKind()) {
4439 Names.push_back(Lookup.first);
4443 assert(isa<CXXRecordDecl>(DC) &&
4444 "Cannot have a constructor name outside of a class!");
4445 ConstructorNameSet.insert(Name);
4449 assert(isa<CXXRecordDecl>(DC) &&
4450 "Cannot have a conversion function name outside of a class!");
4451 ConversionNameSet.insert(Name);
4459 if (
auto *
D = dyn_cast<CXXRecordDecl>(DC)) {
4473 if (ConstructorNameSet.erase(ImplicitCtorName))
4474 Names.push_back(ImplicitCtorName);
4479 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty())
4480 for (
Decl *ChildD : cast<CXXRecordDecl>(DC)->decls())
4481 if (
auto *ChildND = dyn_cast<NamedDecl>(ChildD)) {
4482 auto Name = ChildND->getDeclName();
4483 switch (Name.getNameKind()) {
4488 if (ConstructorNameSet.erase(Name))
4489 Names.push_back(Name);
4493 if (ConversionNameSet.erase(Name))
4494 Names.push_back(Name);
4498 if (ConstructorNameSet.empty() && ConversionNameSet.empty())
4502 assert(ConstructorNameSet.empty() &&
"Failed to find all of the visible "
4503 "constructors by walking all the "
4504 "lexical members of the context.");
4505 assert(ConversionNameSet.empty() &&
"Failed to find all of the visible "
4506 "conversion functions by walking all "
4507 "the lexical members of the context.");
4514 for (
auto &Name : Names)
4526 for (
auto &Name : Names) {
4529 switch (Name.getNameKind()) {
4547 if (!ConstructorDecls.empty())
4548 Generator.insert(ConstructorDecls.front()->getDeclName(),
4549 Trait.getData(ConstructorDecls), Trait);
4550 if (!ConversionDecls.empty())
4551 Generator.insert(ConversionDecls.front()->getDeclName(),
4552 Trait.getData(ConversionDecls), Trait);
4557 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table :
nullptr);
4570 if (isa<NamespaceDecl>(DC) && Chain &&
4573 for (
auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;
4574 Prev = Prev->getPreviousDecl())
4575 if (!Prev->isFromASTFile())
4588 LookupResults.reserve(Map->size());
4589 for (
auto &Entry : *Map)
4590 LookupResults.push_back(
4591 std::make_pair(Entry.first, Entry.second.getLookupResult()));
4594 llvm::sort(LookupResults, llvm::less_first());
4595 for (
auto &NameAndResult : LookupResults) {
4603 assert(
Result.empty() &&
"Cannot have a constructor or conversion "
4604 "function name in a namespace!");
4645 uint64_t Offset = Stream.GetCurrentBitNo();
4647 if (!Map || Map->empty())
4652 GenerateNameLookupTable(Context, DC, LookupTable);
4656 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev,
Record,
4658 ++NumVisibleDeclContexts;
4668void ASTWriter::WriteDeclContextVisibleUpdate(
ASTContext &Context,
4671 if (!Map || Map->empty())
4676 GenerateNameLookupTable(Context, DC, LookupTable);
4680 if (isa<NamespaceDecl>(DC))
4686 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev,
Record, LookupTable);
4696void ASTWriter::WriteOpenCLExtensions(
Sema &SemaRef) {
4702 for (
const auto &I:Opts.OptMap) {
4704 auto V = I.getValue();
4705 Record.push_back(
V.Supported ? 1 : 0);
4706 Record.push_back(
V.Enabled ? 1 : 0);
4707 Record.push_back(
V.WithPragma ? 1 : 0);
4714void ASTWriter::WriteCUDAPragmas(
Sema &SemaRef) {
4715 if (SemaRef.
CUDA().ForceHostDeviceDepth > 0) {
4716 RecordData::value_type
Record[] = {SemaRef.
CUDA().ForceHostDeviceDepth};
4721void ASTWriter::WriteObjCCategories() {
4725 for (
unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
4727 unsigned StartIndex = Categories.size();
4732 Categories.push_back(0);
4736 Cat =
Class->known_categories_begin(),
4737 CatEnd =
Class->known_categories_end();
4738 Cat != CatEnd; ++Cat, ++Size) {
4744 Categories[StartIndex] =
Size;
4748 CategoriesMap.push_back(CatInfo);
4753 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
4756 using namespace llvm;
4758 auto Abbrev = std::make_shared<BitCodeAbbrev>();
4760 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
4761 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4762 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
4765 Stream.EmitRecordWithBlob(AbbrevID,
Record,
4766 reinterpret_cast<char *
>(CategoriesMap.data()),
4773void ASTWriter::WriteLateParsedTemplates(
Sema &SemaRef) {
4780 for (
auto &LPTMapEntry : LPTMap) {
4788 for (
const auto &Tok : LPT.
Toks) {
4796void ASTWriter::WriteOptimizePragmaOptions(
Sema &SemaRef) {
4804void ASTWriter::WriteMSStructPragmaOptions(
Sema &SemaRef) {
4812void ASTWriter::WriteMSPointersToMembersPragmaOptions(
Sema &SemaRef) {
4820void ASTWriter::WritePackPragmaOptions(
Sema &SemaRef) {
4840void ASTWriter::WriteFloatControlPragmaOptions(
Sema &SemaRef) {
4850 for (
const auto &StackEntry : SemaRef.
FpPragmaStack.Stack) {
4851 Record.push_back(StackEntry.Value.getAsOpaqueInt());
4860void ASTWriter::WriteDeclsWithEffectsToVerify(
Sema &SemaRef) {
4870void ASTWriter::WriteModuleFileExtension(
Sema &SemaRef,
4876 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
4878 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4879 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4880 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4881 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4882 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4883 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv));
4889 Record.push_back(Metadata.MajorVersion);
4890 Record.push_back(Metadata.MinorVersion);
4891 Record.push_back(Metadata.BlockName.size());
4892 Record.push_back(Metadata.UserInfo.size());
4894 Buffer += Metadata.BlockName;
4895 Buffer += Metadata.UserInfo;
4896 Stream.EmitRecordWithBlob(Abbrev,
Record, Buffer);
4914 if (!A || (isa<PreferredNameAttr>(A) &&
4915 Writer->isWritingStdCXXNamedModules()))
4916 return Record.push_back(0);
4926 Record.push_back(A->getAttributeSpellingListIndexRaw());
4929#include "clang/Serialization/AttrPCHWrite.inc"
4935 for (
const auto *A : Attrs)
4949 case tok::annot_pragma_loop_hint: {
4953 Record.push_back(Info->Toks.size());
4954 for (
const auto &
T : Info->Toks)
4958 case tok::annot_pragma_pack: {
4961 Record.push_back(
static_cast<unsigned>(Info->Action));
4967 case tok::annot_pragma_openmp:
4968 case tok::annot_pragma_openmp_end:
4969 case tok::annot_pragma_unused:
4970 case tok::annot_pragma_openacc:
4971 case tok::annot_pragma_openacc_end:
4972 case tok::annot_repl_input_end:
4975 llvm_unreachable(
"missing serialization code for annotation token");
4986 Record.push_back(Str.size());
4992 Record.push_back(Str.size());
4993 Blob.insert(Blob.end(), Str.begin(), Str.end());
4997 assert(WritingAST &&
"can't prepare path for output when not writing AST");
5000 StringRef PathStr(
Path.data(),
Path.size());
5001 if (PathStr ==
"<built-in>" || PathStr ==
"<command line>")
5007 const char *PathBegin =
Path.data();
5008 const char *PathPtr =
5010 if (PathPtr != PathBegin) {
5011 Path.erase(
Path.begin(),
Path.begin() + (PathPtr - PathBegin));
5035 Stream.EmitRecordWithBlob(Abbrev,
Record, FilePath);
5040 Record.push_back(Version.getMajor());
5041 if (std::optional<unsigned> Minor = Version.getMinor())
5042 Record.push_back(*Minor + 1);
5045 if (std::optional<unsigned> Subminor = Version.getSubminor())
5046 Record.push_back(*Subminor + 1);
5064 assert(ID < IdentifierOffsets.size());
5065 IdentifierOffsets[ID] = Offset;
5071 unsigned ID = SelectorIDs[Sel];
5072 assert(ID &&
"Unknown selector");
5075 if (ID < FirstSelectorID)
5077 SelectorOffsets[ID - FirstSelectorID] = Offset;
5083 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
5084 bool IncludeTimestamps,
bool BuildingImplicitModule,
5085 bool GeneratingReducedBMI)
5086 : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),
5087 IncludeTimestamps(IncludeTimestamps),
5088 BuildingImplicitModule(BuildingImplicitModule),
5089 GeneratingReducedBMI(GeneratingReducedBMI) {
5090 for (
const auto &Ext : Extensions) {
5091 if (
auto Writer = Ext->createExtensionWriter(*
this))
5092 ModuleFileExtensionWriters.push_back(std::move(Writer));
5099 assert(WritingAST &&
"can't determine lang opts when not writing AST");
5104 return IncludeTimestamps ?
E->getModificationTime() : 0;
5109 StringRef OutputFile,
Module *WritingModule,
5110 StringRef isysroot,
bool ShouldCacheASTInMemory) {
5111 llvm::TimeTraceScope scope(
"WriteAST", OutputFile);
5114 Sema *SemaPtr = Subject.dyn_cast<
Sema *>();
5116 SemaPtr ? SemaPtr->
getPreprocessor() : *cast<Preprocessor *>(Subject);
5118 ASTHasCompilerErrors = PPRef.getDiagnostics().hasUncompilableErrorOccurred();
5121 Stream.Emit((
unsigned)
'C', 8);
5122 Stream.Emit((
unsigned)
'P', 8);
5123 Stream.Emit((
unsigned)
'C', 8);
5124 Stream.Emit((
unsigned)
'H', 8);
5126 WriteBlockInfoBlock();
5129 this->WritingModule = WritingModule;
5130 ASTFileSignature Signature = WriteASTCore(SemaPtr, isysroot, WritingModule);
5132 this->WritingModule =
nullptr;
5133 this->BaseDirectory.clear();
5137 if (WritingModule && PPRef.getHeaderSearchInfo()
5138 .getHeaderSearchOpts()
5139 .ModulesValidateOncePerBuildSession)
5142 if (ShouldCacheASTInMemory) {
5145 llvm::MemoryBuffer::getMemBufferCopy(
5146 StringRef(Buffer.begin(), Buffer.size())));
5151template<
typename Vector>
5153 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true),
E = Vec.end();
5159template <
typename Vector>
5162 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true),
E = Vec.end();
5168void ASTWriter::computeNonAffectingInputFiles() {
5172 IsSLocAffecting.resize(N,
true);
5173 IsSLocFileEntryAffecting.resize(N,
true);
5178 auto AffectingModuleMaps = GetAffectingModuleMaps(*PP, WritingModule);
5180 unsigned FileIDAdjustment = 0;
5181 unsigned OffsetAdjustment = 0;
5183 NonAffectingFileIDAdjustments.reserve(N);
5184 NonAffectingOffsetAdjustments.reserve(N);
5186 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
5187 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
5189 for (
unsigned I = 1; I != N; ++I) {
5191 FileID FID = FileID::get(I);
5198 if (!
Cache->OrigEntry)
5206 if (!AffectingModuleMaps)
5210 if (AffectingModuleMaps->DefinitionFileIDs.contains(FID))
5213 IsSLocAffecting[I] =
false;
5214 IsSLocFileEntryAffecting[I] =
5215 AffectingModuleMaps->DefinitionFiles.contains(*
Cache->OrigEntry);
5217 FileIDAdjustment += 1;
5223 if (!NonAffectingFileIDs.empty() &&
5224 NonAffectingFileIDs.back().ID == FID.ID - 1) {
5225 NonAffectingFileIDs.back() = FID;
5227 NonAffectingFileIDAdjustments.back() = FileIDAdjustment;
5228 NonAffectingOffsetAdjustments.back() = OffsetAdjustment;
5232 NonAffectingFileIDs.push_back(FID);
5235 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
5236 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
5245 for (StringRef
Path :
5248 for (
unsigned I = 1; I != N; ++I) {
5249 if (IsSLocAffecting[I]) {
5255 if (!
Cache->OrigEntry)
5258 Cache->OrigEntry->getNameAsRequested());
5264void ASTWriter::PrepareWritingSpecialDecls(
Sema &SemaRef) {
5267 bool isModule = WritingModule !=
nullptr;
5274 PredefinedDecls.insert(
D);
5282 RegisterPredefDecl(Context.ObjCProtocolClassDecl,
5286 RegisterPredefDecl(Context.ObjCInstanceTypeDecl,
5290 RegisterPredefDecl(Context.BuiltinMSVaListDecl,
5295 RegisterPredefDecl(Context.MakeIntegerSeqDecl,
5297 RegisterPredefDecl(Context.CFConstantStringTypeDecl,
5299 RegisterPredefDecl(Context.CFConstantStringTagDecl,
5301 RegisterPredefDecl(Context.TypePackElementDecl,
5315 if (GeneratingReducedBMI) {
5341 if (GeneratingReducedBMI)
5364 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I)
5375 "There are local ones at end of translation unit!");
5388 for (
const auto &I : SemaRef.KnownNamespaces)
5395 for (
const auto &I : Undefined)
5401 for (
const auto &DeleteExprsInfo :
5408 for (
const auto *I : DeclsToEmitEvenIfUnreferenced)
5410 DeclsToEmitEvenIfUnreferenced.clear();
5422 llvm::sort(IIs, llvm::deref<std::less<>>());
5429 for (
auto *
D : SemaRef.DeclsToCheckForDeferredDiags)
5437 PendingEmittingVTables.clear();
5440void ASTWriter::WriteSpecialDeclRecords(
Sema &SemaRef) {
5443 bool isModule = WritingModule !=
nullptr;
5446 if (!EagerlyDeserializedDecls.empty())
5449 if (!ModularCodegenDecls.empty())
5455 TentativeDefinitions);
5456 if (!TentativeDefinitions.empty())
5463 UnusedFileScopedDecls);
5464 if (!UnusedFileScopedDecls.empty())
5470 if (!ExtVectorDecls.empty())
5476 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I) {
5492 if (!UnusedLocalTypedefNameCandidates.empty())
5494 UnusedLocalTypedefNameCandidates);
5505 if (!PendingInstantiations.empty())
5511 auto AddEmittedDeclRefOrZero = [
this, &SemaDeclRefs](
Decl *
D) {
5513 SemaDeclRefs.push_back(0);
5522 if (!SemaDeclRefs.empty())
5527 for (
auto *
D : SemaRef.DeclsToCheckForDeferredDiags)
5530 if (!DeclsToCheckForDeferredDiags.empty())
5532 DeclsToCheckForDeferredDiags);
5538 AddDeclRef(CudaCallDecl, CUDASpecialDeclRefs);
5546 DelegatingCtorDecls);
5547 if (!DelegatingCtorDecls.empty())
5552 for (
const auto &I : SemaRef.KnownNamespaces) {
5556 if (!KnownNamespaces.empty())
5563 for (
const auto &I : Undefined) {
5570 if (!UndefinedButUsed.empty())
5577 for (
const auto &DeleteExprsInfo :
5582 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze);
5583 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());
5584 for (
const auto &DeleteLoc : DeleteExprsInfo.second) {
5586 DeleteExprsToAnalyze.push_back(DeleteLoc.second);
5590 if (!DeleteExprsToAnalyze.empty())
5601 if (!VTablesToEmit.empty())
5607 using namespace llvm;
5609 bool isModule = WritingModule !=
nullptr;
5617 computeNonAffectingInputFiles();
5619 writeUnhashedControlBlock(*PP);
5632 IdentifierIDs.clear();
5645 if (IsInterestingNonMacroIdentifier(
ID.second, *
this))
5646 IIs.push_back(
ID.second);
5649 llvm::sort(IIs, llvm::deref<std::less<>>());
5658 for (
const auto &WeakUndeclaredIdentifierList :
5660 const IdentifierInfo *
const II = WeakUndeclaredIdentifierList.first;
5661 for (
const auto &WI : WeakUndeclaredIdentifierList.second) {
5677 AddTypeRef(Context, Context.ObjCIdRedefinitionType, SpecialTypes);
5678 AddTypeRef(Context, Context.ObjCClassRedefinitionType, SpecialTypes);
5679 AddTypeRef(Context, Context.ObjCSelRedefinitionType, SpecialTypes);
5684 PrepareWritingSpecialDecls(*SemaPtr);
5687 WriteControlBlock(*PP, isysroot);
5690 Stream.FlushToWord();
5691 ASTBlockRange.first = Stream.GetCurrentBitNo() >> 3;
5693 ASTBlockStartOffset = Stream.GetCurrentBitNo();
5711 for (
auto &SelectorAndID : SelectorIDs)
5712 AllSelectors.push_back(SelectorAndID.first);
5713 for (
auto &
Selector : AllSelectors)
5737 auto Abbrev = std::make_shared<BitCodeAbbrev>();
5739 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
5740 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
5743 llvm::raw_svector_ostream Out(Buffer);
5745 using namespace llvm::support;
5747 endian::Writer
LE(Out, llvm::endianness::little);
5748 LE.write<uint8_t>(
static_cast<uint8_t
>(M.
Kind));
5750 LE.write<uint16_t>(Name.size());
5751 Out.write(Name.data(), Name.size());
5757 auto writeBaseIDOrNone = [&](
auto BaseID,
bool ShouldWrite) {
5758 assert(BaseID < std::numeric_limits<uint32_t>::max() &&
"base id too high");
5775 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev,
Record,
5776 Buffer.data(), Buffer.size());
5780 WriteDeclAndTypes(SemaPtr->
Context);
5782 WriteFileDeclIDsMap();
5785 WriteComments(SemaPtr->
Context);
5786 WritePreprocessor(*PP, isModule);
5789 WriteSelectors(*SemaPtr);
5790 WriteReferencedSelectorsPool(*SemaPtr);
5791 WriteLateParsedTemplates(*SemaPtr);
5793 WriteIdentifierTable(*PP, SemaPtr ? &SemaPtr->
IdResolver :
nullptr, isModule);
5796 WriteOpenCLExtensions(*SemaPtr);
5797 WriteCUDAPragmas(*SemaPtr);
5802 WriteSubmodules(WritingModule, SemaPtr ? &SemaPtr->
Context :
nullptr);
5807 WriteSpecialDeclRecords(*SemaPtr);
5810 if (!WeakUndeclaredIdentifiers.empty())
5812 WeakUndeclaredIdentifiers);
5814 if (!WritingModule) {
5824 assert(SubmoduleIDs.contains(I->getImportedModule()));
5825 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
5826 I->getImportedModule()));
5830 if (!Imports.empty()) {
5831 auto Cmp = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5834 auto Eq = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5835 return A.ID == B.ID;
5839 llvm::sort(Imports, Cmp);
5840 Imports.erase(std::unique(Imports.begin(), Imports.end(),
Eq),
5844 for (
const auto &Import : Imports) {
5845 ImportedModules.push_back(
Import.ID);
5856 WriteObjCCategories();
5858 if (!WritingModule) {
5859 WriteOptimizePragmaOptions(*SemaPtr);
5860 WriteMSStructPragmaOptions(*SemaPtr);
5861 WriteMSPointersToMembersPragmaOptions(*SemaPtr);
5863 WritePackPragmaOptions(*SemaPtr);
5864 WriteFloatControlPragmaOptions(*SemaPtr);
5865 WriteDeclsWithEffectsToVerify(*SemaPtr);
5869 RecordData::value_type
Record[] = {
5870 NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts};
5873 Stream.FlushToWord();
5874 ASTBlockRange.second = Stream.GetCurrentBitNo() >> 3;
5878 for (
const auto &ExtWriter : ModuleFileExtensionWriters)
5879 WriteModuleFileExtension(*SemaPtr, *ExtWriter);
5881 return backpatchSignature();
5884void ASTWriter::EnteringModulePurview() {
5887 if (GeneratingReducedBMI)
5888 DeclUpdatesFromGMF.swap(DeclUpdates);
5894void ASTWriter::AddedManglingNumber(
const Decl *
D,
unsigned Number) {
5900void ASTWriter::AddedStaticLocalNumbers(
const Decl *
D,
unsigned Number) {
5919void ASTWriter::WriteDeclAndTypes(
ASTContext &Context) {
5924 DeclTypesBlockStartOffset = Stream.GetCurrentBitNo();
5928 WriteDeclUpdatesBlocks(Context, DeclUpdatesOffsetsRecord);
5929 while (!DeclTypesToEmit.empty()) {
5930 DeclOrType DOT = DeclTypesToEmit.front();
5931 DeclTypesToEmit.pop();
5933 WriteType(Context, DOT.getType());
5935 WriteDecl(Context, DOT.getDecl());
5937 }
while (!DeclUpdates.empty());
5939 DoneWritingDeclsAndTypes =
true;
5943 assert(DelayedNamespace.empty() || GeneratingReducedBMI);
5946 uint64_t LexicalOffset = WriteDeclContextLexicalBlock(Context, NS);
5947 uint64_t VisibleOffset = WriteDeclContextVisibleBlock(Context, NS);
5951 LexicalOffset -= DeclTypesBlockStartOffset;
5954 VisibleOffset -= DeclTypesBlockStartOffset;
5957 DelayedNamespaceRecord.push_back(LexicalOffset);
5958 DelayedNamespaceRecord.push_back(VisibleOffset);
5963 assert(DeclTypesToEmit.empty());
5964 assert(DeclUpdates.empty());
5969 WriteTypeDeclOffsets();
5970 if (!DeclUpdatesOffsetsRecord.empty())
5973 if (!DelayedNamespaceRecord.empty())
5975 DelayedNamespaceRecord);
5977 if (!RelatedDeclsMap.empty()) {
5981 for (
const auto &Pair : RelatedDeclsMap) {
5982 RelatedDeclsMapRecord.push_back(Pair.first.getRawValue());
5983 RelatedDeclsMapRecord.push_back(Pair.second.size());
5984 for (
const auto &Lambda : Pair.second)
5985 RelatedDeclsMapRecord.push_back(Lambda.getRawValue());
5988 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
5990 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array));
5991 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
5992 unsigned FunctionToLambdaMapAbbrev = Stream.EmitAbbrev(std::move(Abv));
5994 FunctionToLambdaMapAbbrev);
5997 if (!SpecializationsUpdates.empty()) {
5998 WriteSpecializationsUpdates(
false);
5999 SpecializationsUpdates.clear();
6002 if (!PartialSpecializationsUpdates.empty()) {
6003 WriteSpecializationsUpdates(
true);
6004 PartialSpecializationsUpdates.clear();
6019 NewGlobalKindDeclPairs.push_back(
D->
getKind());
6020 NewGlobalKindDeclPairs.push_back(
GetDeclRef(
D).getRawValue());
6023 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
6025 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
6026 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
6029 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev,
Record,
6030 bytes(NewGlobalKindDeclPairs));
6032 Abv = std::make_shared<llvm::BitCodeAbbrev>();
6034 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
6035 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
6036 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));
6039 WriteDeclContextVisibleUpdate(Context, TU);
6042 if (Context.ExternCContext)
6043 WriteDeclContextVisibleUpdate(Context, Context.ExternCContext);
6046 for (
auto *DC : UpdatedDeclContexts)
6047 WriteDeclContextVisibleUpdate(Context, DC);
6050void ASTWriter::WriteSpecializationsUpdates(
bool IsPartial) {
6054 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
6056 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
6057 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
6058 auto UpdateSpecializationAbbrev = Stream.EmitAbbrev(std::move(Abv));
6061 IsPartial ? PartialSpecializationsUpdates : SpecializationsUpdates;
6062 for (
auto &SpecializationUpdate : SpecUpdates) {
6063 const NamedDecl *
D = SpecializationUpdate.first;
6066 GenerateSpecializationInfoLookupTable(
D, SpecializationUpdate.second,
6067 LookupTable, IsPartial);
6070 RecordData::value_type
Record[] = {
6071 static_cast<RecordData::value_type
>(
RecordType),
6073 Stream.EmitRecordWithBlob(UpdateSpecializationAbbrev,
Record, LookupTable);
6077void ASTWriter::WriteDeclUpdatesBlocks(
ASTContext &Context,
6078 RecordDataImpl &OffsetsRecord) {
6079 if (DeclUpdates.empty())
6082 DeclUpdateMap LocalUpdates;
6083 LocalUpdates.swap(DeclUpdates);
6085 for (
auto &DeclUpdate : LocalUpdates) {
6086 const Decl *
D = DeclUpdate.first;
6088 bool HasUpdatedBody =
false;
6089 bool HasAddedVarDefinition =
false;
6092 for (
auto &
Update : DeclUpdate.second) {
6098 HasUpdatedBody =
true;
6100 HasAddedVarDefinition =
true;
6107 assert(
Update.getDecl() &&
"no decl to add?");
6121 cast<ParmVarDecl>(
Update.getDecl())->getDefaultArg());
6126 cast<FieldDecl>(
Update.getDecl())->getInClassInitializer());
6130 auto *RD = cast<CXXRecordDecl>(
D);
6131 UpdatedDeclContexts.insert(RD->getPrimaryContext());
6132 Record.push_back(RD->isParamDestroyedInCallee());
6133 Record.push_back(llvm::to_underlying(RD->getArgPassingRestrictions()));
6134 Record.AddCXXDefinitionData(RD);
6135 Record.AddOffset(WriteDeclContextLexicalBlock(Context, RD));
6140 if (
auto *MSInfo = RD->getMemberSpecializationInfo()) {
6141 Record.push_back(MSInfo->getTemplateSpecializationKind());
6142 Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
6144 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
6145 Record.push_back(Spec->getTemplateSpecializationKind());
6146 Record.AddSourceLocation(Spec->getPointOfInstantiation());
6150 auto From = Spec->getInstantiatedFrom();
6151 if (
auto PartialSpec =
6154 Record.AddDeclRef(PartialSpec);
6155 Record.AddTemplateArgumentList(
6156 &Spec->getTemplateInstantiationArgs());
6161 Record.push_back(llvm::to_underlying(RD->getTagKind()));
6162 Record.AddSourceLocation(RD->getLocation());
6163 Record.AddSourceLocation(RD->getBeginLoc());
6164 Record.AddSourceRange(RD->getBraceRange());
6177 Record.AddStmt(cast<CXXDestructorDecl>(
D)->getOperatorDeleteThisArg());
6183 Record.writeExceptionSpecInfo(prototype->getExceptionSpecInfo());
6201 D->
getAttr<OMPThreadPrivateDeclAttr>()->getRange());
6205 auto *A =
D->
getAttr<OMPAllocateDeclAttr>();
6206 Record.push_back(A->getAllocatorType());
6207 Record.AddStmt(A->getAllocator());
6208 Record.AddStmt(A->getAlignment());
6209 Record.AddSourceRange(A->getRange());
6214 Record.push_back(
D->
getAttr<OMPDeclareTargetDeclAttr>()->getMapType());
6216 D->
getAttr<OMPDeclareTargetDeclAttr>()->getRange());
6232 if (HasUpdatedBody) {
6233 const auto *Def = cast<FunctionDecl>(
D);
6235 Record.push_back(Def->isInlined());
6236 Record.AddSourceLocation(Def->getInnerLocStart());
6237 Record.AddFunctionDefinition(Def);
6238 }
else if (HasAddedVarDefinition) {
6239 const auto *VD = cast<VarDecl>(
D);
6241 Record.push_back(VD->isInline());
6242 Record.push_back(VD->isInlineSpecified());
6243 Record.AddVarDeclInit(VD);
6260 NonAffectingFileIDs.empty())
6262 auto It = llvm::lower_bound(NonAffectingFileIDs, FID);
6263 unsigned Idx = std::distance(NonAffectingFileIDs.begin(), It);
6264 unsigned Offset = NonAffectingFileIDAdjustments[Idx];
6265 return FileID::get(FID.getOpaqueValue() - Offset);
6268unsigned ASTWriter::getAdjustedNumCreatedFIDs(
FileID FID)
const {
6274 unsigned AdjustedNumCreatedFIDs = 0;
6275 for (
unsigned I = FID.ID, N = I + NumCreatedFIDs; I != N; ++I)
6276 if (IsSLocAffecting[I])
6277 ++AdjustedNumCreatedFIDs;
6278 return AdjustedNumCreatedFIDs;
6294 return Offset - getAdjustment(Offset);
6299 if (NonAffectingRanges.empty())
6305 if (Offset > NonAffectingRanges.back().getEnd().getOffset())
6306 return NonAffectingOffsetAdjustments.back();
6308 if (Offset < NonAffectingRanges.front().getBegin().getOffset())
6315 auto It = llvm::lower_bound(NonAffectingRanges, Offset, Contains);
6316 unsigned Idx = std::distance(NonAffectingRanges.begin(), It);
6317 return NonAffectingOffsetAdjustments[Idx];
6321 Record.push_back(getAdjustedFileID(FID).getOpaqueValue());
6326 unsigned BaseOffset = 0;
6327 unsigned ModuleFileIndex = 0;
6333 SourceManager::MaxLoadedOffset -
Loc.getOffset() - 1);
6334 assert(SLocMapI !=
getChain()->GlobalSLocOffsetMap.end() &&
6335 "Corrupted global sloc offset map");
6340 ModuleFileIndex = F->
Index + 1;
6349 Loc = getAdjustedLocation(
Loc);
6387 MacroInfoToEmitData Info = { Name, MI, ID };
6388 MacroInfosToEmit.push_back(Info);
6397 assert(MacroIDs.contains(MI) &&
"Macro not emitted!");
6398 return MacroIDs[MI];
6402 return IdentMacroDirectivesOffsetMap.lookup(Name);
6406 Record->push_back(Writer->getSelectorRef(SelRef));
6415 if (SID == 0 && Chain) {
6419 SID = SelectorIDs[Sel];
6422 SID = NextSelectorID++;
6423 SelectorIDs[Sel] = SID;
6465 bool InfoHasSameExpr
6467 Record->push_back(InfoHasSameExpr);
6468 if (InfoHasSameExpr)
6486 TypeLocWriter TLW(*
this,
Seq);
6496template <
typename IdxForTypeTy>
6498 IdxForTypeTy IdxForType) {
6502 unsigned FastQuals =
T.getLocalFastQualifiers();
6503 T.removeLocalFastQualifiers();
6505 if (
T.hasLocalNonFastQualifiers())
6506 return IdxForType(
T).asTypeID(FastQuals);
6508 assert(!
T.hasLocalQualifiers());
6510 if (
const BuiltinType *BT = dyn_cast<BuiltinType>(
T.getTypePtr()))
6518 return IdxForType(
T).asTypeID(FastQuals);
6525 assert(!
T.getLocalFastQualifiers());
6529 if (DoneWritingDeclsAndTypes) {
6530 assert(0 &&
"New type seen after serializing all the types to emit!");
6536 Idx =
TypeIdx(0, NextTypeID++);
6537 DeclTypesToEmit.push(
T);
6555 assert(WritingAST &&
"Cannot request a declaration ID before AST writing");
6562 if (
auto *
Iter = DeclUpdatesFromGMF.find(
D);
6563 Iter != DeclUpdatesFromGMF.end()) {
6565 DeclUpdates[
D].push_back(
Update);
6566 DeclUpdatesFromGMF.erase(
Iter);
6578 assert(!(
reinterpret_cast<uintptr_t>(
D) & 0x01) &&
"Invalid decl pointer");
6580 if (ID.isInvalid()) {
6581 if (DoneWritingDeclsAndTypes) {
6582 assert(0 &&
"New decl seen after serializing all the decls to emit!");
6589 DeclTypesToEmit.push(
const_cast<Decl *
>(
D));
6604 assert(DeclIDs.contains(
D) &&
"Declaration not emitted!");
6611 assert(DoneWritingDeclsAndTypes &&
6612 "wasDeclEmitted should only be called after writing declarations");
6617 bool Emitted = DeclIDs.contains(
D);
6619 GeneratingReducedBMI) &&
6620 "The declaration within modules can only be omitted in reduced BMI.");
6625 assert(ID.isValid());
6639 if (isa<ParmVarDecl, TemplateTemplateParmDecl>(
D))
6644 assert(
SM.isLocalSourceLocation(FileLoc));
6647 std::tie(FID, Offset) =
SM.getDecomposedLoc(FileLoc);
6650 assert(
SM.getSLocEntry(FID).isFile());
6651 assert(IsSLocAffecting[FID.ID]);
6653 std::unique_ptr<DeclIDInFileInfo> &Info = FileDeclIDs[FID];
6655 Info = std::make_unique<DeclIDInFileInfo>();
6657 std::pair<unsigned, LocalDeclID> LocDecl(Offset, ID);
6658 LocDeclIDsTy &Decls = Info->DeclIDs;
6659 Decls.push_back(LocDecl);
6664 "expected an anonymous declaration");
6668 auto It = AnonymousDeclarationNumbers.find(
D);
6669 if (It == AnonymousDeclarationNumbers.end()) {
6672 AnonymousDeclarationNumbers[ND] = Number;
6675 It = AnonymousDeclarationNumbers.find(
D);
6676 assert(It != AnonymousDeclarationNumbers.end() &&
6677 "declaration not found within its lexical context");
6685 switch (Name.getNameKind()) {
6732 NestedNames.push_back(NNS);
6736 Record->push_back(NestedNames.size());
6737 while(!NestedNames.empty()) {
6738 NNS = NestedNames.pop_back_val();
6780 assert(TemplateParams &&
"No TemplateParams!");
6786 for (
const auto &
P : *TemplateParams)
6792 Record->push_back(
false);
6799 assert(TemplateArgs &&
"No TemplateArgs!");
6801 for (
int i = 0, e = TemplateArgs->
size(); i != e; ++i)
6807 assert(ASTTemplArgList &&
"No ASTTemplArgList!");
6819 I =
Set.begin(),
E =
Set.end(); I !=
E; ++I) {
6821 Record->push_back(I.getAccess());
6829 Record->push_back(
Base.getAccessSpecifierAsWritten());
6830 Record->push_back(
Base.getInheritConstructors());
6843 for (
auto &
Base : Bases)
6861 for (
auto *
Init : CtorInits) {
6862 if (
Init->isBaseInitializer()) {
6866 }
else if (
Init->isDelegatingInitializer()) {
6869 }
else if (
Init->isMemberInitializer()){
6882 if (
Init->isWritten())
6896 auto &
Data =
D->data();
6902#define FIELD(Name, Width, Merge) \
6903 if (!DefinitionBits.canWriteNextNBits(Width)) { \
6904 Record->push_back(DefinitionBits); \
6905 DefinitionBits.reset(0); \
6907 DefinitionBits.addBits(Data.Name, Width);
6909#include "clang/AST/CXXRecordDeclDefinitionBits.def"
6912 Record->push_back(DefinitionBits);
6916 Record->push_back(
D->getODRHash());
6918 bool ModulesCodegen =
6919 !
D->isDependentType() &&
6921 Record->push_back(ModulesCodegen);
6923 Writer->AddDeclRef(
D, Writer->ModularCodegenDecls);
6928 Record->push_back(
Data.ComputedVisibleConversions);
6929 if (
Data.ComputedVisibleConversions)
6933 if (!
Data.IsLambda) {
6935 if (
Data.NumBases > 0)
6940 if (
Data.NumVBases > 0)
6945 auto &Lambda =
D->getLambdaData();
6948 LambdaBits.
addBits(Lambda.DependencyKind, 2);
6949 LambdaBits.
addBit(Lambda.IsGenericLambda);
6950 LambdaBits.
addBits(Lambda.CaptureDefault, 2);
6951 LambdaBits.
addBits(Lambda.NumCaptures, 15);
6952 LambdaBits.
addBit(Lambda.HasKnownInternalLinkage);
6953 Record->push_back(LambdaBits);
6955 Record->push_back(Lambda.NumExplicitCaptures);
6956 Record->push_back(Lambda.ManglingNumber);
6957 Record->push_back(
D->getDeviceLambdaManglingNumber());
6961 for (
unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
6968 Record->push_back(CaptureBits);
6970 switch (
Capture.getCaptureKind()) {
6997 Val |= (ES->HasConstantInitialization ? 2 : 0);
6998 Val |= (ES->HasConstantDestruction ? 4 : 0);
7012void ASTWriter::ReaderInitialized(
ASTReader *Reader) {
7013 assert(Reader &&
"Cannot remove chain");
7014 assert((!Chain || Chain == Reader) &&
"Cannot replace chain");
7015 assert(FirstDeclID == NextDeclID &&
7016 FirstTypeID == NextTypeID &&
7017 FirstIdentID == NextIdentID &&
7018 FirstMacroID == NextMacroID &&
7019 FirstSubmoduleID == NextSubmoduleID &&
7020 FirstSelectorID == NextSelectorID &&
7021 "Setting chain after writing has started.");
7030 NextMacroID = FirstMacroID;
7031 NextSelectorID = FirstSelectorID;
7032 NextSubmoduleID = FirstSubmoduleID;
7042 unsigned OriginalModuleFileIndex = StoredID >> 32;
7046 if (OriginalModuleFileIndex == 0 && StoredID)
7057 MacroID &StoredID = MacroIDs[MI];
7080 if (ModuleFileIndex == 0 && StoredIdx.
getValue())
7092 PredefinedDecls.insert(
D);
7104 assert(!MacroDefinitions.contains(MD));
7105 MacroDefinitions[MD] =
ID;
7109 assert(!SubmoduleIDs.contains(Mod));
7110 SubmoduleIDs[Mod] =
ID;
7113void ASTWriter::CompletedTagDefinition(
const TagDecl *
D) {
7115 assert(
D->isCompleteDefinition());
7116 assert(!WritingAST &&
"Already writing the AST!");
7117 if (
auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
7119 if (RD->isFromASTFile()) {
7124 "completed a tag from another module but not by instantiation?");
7125 DeclUpdates[RD].push_back(
7143 "Should not add lookup results to non-lookup contexts!");
7146 if (isa<TranslationUnitDecl>(DC))
7154 !isa<FunctionTemplateDecl>(
D))
7164 assert(!WritingAST &&
"Already writing the AST!");
7165 if (UpdatedDeclContexts.insert(DC) && !cast<Decl>(DC)->isFromASTFile()) {
7169 llvm::append_range(DeclsToEmitEvenIfUnreferenced, DC->
decls());
7171 DeclsToEmitEvenIfUnreferenced.push_back(
D);
7183 if (!isa<CXXMethodDecl>(
D))
7188 assert(!WritingAST &&
"Already writing the AST!");
7192void ASTWriter::ResolvedExceptionSpec(
const FunctionDecl *FD) {
7194 assert(!DoneWritingDeclsAndTypes &&
"Already done writing updates!");
7201 ->castAs<FunctionProtoType>()
7202 ->getExceptionSpecType()))
7209 assert(!WritingAST &&
"Already writing the AST!");
7212 DeclUpdates[
D].push_back(
7221 assert(!WritingAST &&
"Already writing the AST!");
7222 assert(
Delete &&
"Not given an operator delete");
7229void ASTWriter::CompletedImplicitDefinition(
const FunctionDecl *
D) {
7231 assert(!WritingAST &&
"Already writing the AST!");
7236 if (!
D->doesThisDeclarationHaveABody())
7243void ASTWriter::VariableDefinitionInstantiated(
const VarDecl *
D) {
7245 assert(!WritingAST &&
"Already writing the AST!");
7252void ASTWriter::FunctionDefinitionInstantiated(
const FunctionDecl *
D) {
7254 assert(!WritingAST &&
"Already writing the AST!");
7259 if (!
D->doesThisDeclarationHaveABody())
7265void ASTWriter::InstantiationRequested(
const ValueDecl *
D) {
7267 assert(!WritingAST &&
"Already writing the AST!");
7274 if (
auto *VD = dyn_cast<VarDecl>(
D))
7275 POI = VD->getPointOfInstantiation();
7277 POI = cast<FunctionDecl>(
D)->getPointOfInstantiation();
7281void ASTWriter::DefaultArgumentInstantiated(
const ParmVarDecl *
D) {
7283 assert(!WritingAST &&
"Already writing the AST!");
7287 DeclUpdates[
D].push_back(
7291void ASTWriter::DefaultMemberInitializerInstantiated(
const FieldDecl *
D) {
7292 assert(!WritingAST &&
"Already writing the AST!");
7296 DeclUpdates[
D].push_back(
7303 assert(!WritingAST &&
"Already writing the AST!");
7307 assert(IFD->
getDefinition() &&
"Category on a class without a definition?");
7308 ObjCClassesWithCategories.insert(
7312void ASTWriter::DeclarationMarkedUsed(
const Decl *
D) {
7314 assert(!WritingAST &&
"Already writing the AST!");
7326void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(
const Decl *
D) {
7328 assert(!WritingAST &&
"Already writing the AST!");
7335void ASTWriter::DeclarationMarkedOpenMPAllocate(
const Decl *
D,
const Attr *A) {
7337 assert(!WritingAST &&
"Already writing the AST!");
7344void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(
const Decl *
D,
7347 assert(!WritingAST &&
"Already writing the AST!");
7351 DeclUpdates[
D].push_back(
7357 assert(!WritingAST &&
"Already writing the AST!");
7362void ASTWriter::AddedAttributeToRecord(
const Attr *
Attr,
7365 assert(!WritingAST &&
"Already writing the AST!");
7366 if (!
Record->isFromASTFile())
7371void ASTWriter::AddedCXXTemplateSpecialization(
7373 assert(!WritingAST &&
"Already writing the AST!");
7380 DeclsToEmitEvenIfUnreferenced.push_back(
D);
7383void ASTWriter::AddedCXXTemplateSpecialization(
7385 assert(!WritingAST &&
"Already writing the AST!");
7392 DeclsToEmitEvenIfUnreferenced.push_back(
D);
7397 assert(!WritingAST &&
"Already writing the AST!");
7404 DeclsToEmitEvenIfUnreferenced.push_back(
D);
7418#define GEN_CLANG_CLAUSE_CLASS
7419#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
7420#include "llvm/Frontend/OpenMP/OMP.inc"
7429 OMPClauseWriter(*this).writeClause(
C);
7432void OMPClauseWriter::writeClause(
OMPClause *
C) {
7433 Record.push_back(
unsigned(
C->getClauseKind()));
7435 Record.AddSourceLocation(
C->getBeginLoc());
7436 Record.AddSourceLocation(
C->getEndLoc());
7440 Record.push_back(uint64_t(
C->getCaptureRegion()));
7441 Record.AddStmt(
C->getPreInitStmt());
7445 VisitOMPClauseWithPreInit(
C);
7446 Record.AddStmt(
C->getPostUpdateExpr());
7449void OMPClauseWriter::VisitOMPIfClause(
OMPIfClause *
C) {
7450 VisitOMPClauseWithPreInit(
C);
7452 Record.AddSourceLocation(
C->getNameModifierLoc());
7453 Record.AddSourceLocation(
C->getColonLoc());
7454 Record.AddStmt(
C->getCondition());
7455 Record.AddSourceLocation(
C->getLParenLoc());
7459 VisitOMPClauseWithPreInit(
C);
7460 Record.AddStmt(
C->getCondition());
7461 Record.AddSourceLocation(
C->getLParenLoc());
7465 VisitOMPClauseWithPreInit(
C);
7466 Record.AddStmt(
C->getNumThreads());
7467 Record.AddSourceLocation(
C->getLParenLoc());
7471 Record.AddStmt(
C->getSafelen());
7472 Record.AddSourceLocation(
C->getLParenLoc());
7476 Record.AddStmt(
C->getSimdlen());
7477 Record.AddSourceLocation(
C->getLParenLoc());
7481 Record.push_back(
C->getNumSizes());
7482 for (
Expr *Size :
C->getSizesRefs())
7484 Record.AddSourceLocation(
C->getLParenLoc());
7488 Record.push_back(
C->getNumLoops());
7489 for (
Expr *Size :
C->getArgsRefs())
7491 Record.AddSourceLocation(
C->getLParenLoc());
7497 Record.AddStmt(
C->getFactor());
7498 Record.AddSourceLocation(
C->getLParenLoc());
7502 Record.AddStmt(
C->getAllocator());
7503 Record.AddSourceLocation(
C->getLParenLoc());
7507 Record.AddStmt(
C->getNumForLoops());
7508 Record.AddSourceLocation(
C->getLParenLoc());
7512 Record.AddStmt(
C->getEventHandler());
7513 Record.AddSourceLocation(
C->getLParenLoc());
7517 Record.push_back(
unsigned(
C->getDefaultKind()));
7518 Record.AddSourceLocation(
C->getLParenLoc());
7519 Record.AddSourceLocation(
C->getDefaultKindKwLoc());
7523 Record.push_back(
unsigned(
C->getProcBindKind()));
7524 Record.AddSourceLocation(
C->getLParenLoc());
7525 Record.AddSourceLocation(
C->getProcBindKindKwLoc());
7529 VisitOMPClauseWithPreInit(
C);
7530 Record.push_back(
C->getScheduleKind());
7531 Record.push_back(
C->getFirstScheduleModifier());
7532 Record.push_back(
C->getSecondScheduleModifier());
7533 Record.AddStmt(
C->getChunkSize());
7534 Record.AddSourceLocation(
C->getLParenLoc());
7535 Record.AddSourceLocation(
C->getFirstScheduleModifierLoc());
7536 Record.AddSourceLocation(
C->getSecondScheduleModifierLoc());
7537 Record.AddSourceLocation(
C->getScheduleKindLoc());
7538 Record.AddSourceLocation(
C->getCommaLoc());
7542 Record.push_back(
C->getLoopNumIterations().size());
7543 Record.AddStmt(
C->getNumForLoops());
7544 for (
Expr *NumIter :
C->getLoopNumIterations())
7546 for (
unsigned I = 0,
E =
C->getLoopNumIterations().size(); I <
E; ++I)
7547 Record.AddStmt(
C->getLoopCounter(I));
7548 Record.AddSourceLocation(
C->getLParenLoc());
7562 Record.push_back(
C->isExtended() ? 1 : 0);
7563 if (
C->isExtended()) {
7564 Record.AddSourceLocation(
C->getLParenLoc());
7565 Record.AddSourceLocation(
C->getArgumentLoc());
7566 Record.writeEnum(
C->getDependencyKind());
7576 Record.AddSourceLocation(
C->getLParenLoc());
7577 Record.AddSourceLocation(
C->getFailParameterLoc());
7578 Record.writeEnum(
C->getFailParameter());
7586 Record.push_back(
static_cast<uint64_t>(
C->getDirectiveKinds().size()));
7587 Record.AddSourceLocation(
C->getLParenLoc());
7588 for (
auto K :
C->getDirectiveKinds()) {
7595 Record.AddSourceLocation(
C->getLParenLoc());
7599 Record.push_back(
static_cast<uint64_t>(
C->getDirectiveKinds().size()));
7600 Record.AddSourceLocation(
C->getLParenLoc());
7601 for (
auto K :
C->getDirectiveKinds()) {
7608void OMPClauseWriter::VisitOMPNoOpenMPRoutinesClause(
7628 Record.push_back(
C->varlist_size());
7629 for (
Expr *VE :
C->varlist())
7631 Record.writeBool(
C->getIsTarget());
7632 Record.writeBool(
C->getIsTargetSync());
7633 Record.AddSourceLocation(
C->getLParenLoc());
7634 Record.AddSourceLocation(
C->getVarLoc());
7638 Record.AddStmt(
C->getInteropVar());
7639 Record.AddSourceLocation(
C->getLParenLoc());
7640 Record.AddSourceLocation(
C->getVarLoc());
7644 Record.AddStmt(
C->getInteropVar());
7645 Record.AddSourceLocation(
C->getLParenLoc());
7646 Record.AddSourceLocation(
C->getVarLoc());
7650 VisitOMPClauseWithPreInit(
C);
7651 Record.AddStmt(
C->getCondition());
7652 Record.AddSourceLocation(
C->getLParenLoc());
7656 VisitOMPClauseWithPreInit(
C);
7657 Record.AddStmt(
C->getCondition());
7658 Record.AddSourceLocation(
C->getLParenLoc());
7662 VisitOMPClauseWithPreInit(
C);
7663 Record.AddStmt(
C->getThreadID());
7664 Record.AddSourceLocation(
C->getLParenLoc());
7668 Record.AddStmt(
C->getAlignment());
7669 Record.AddSourceLocation(
C->getLParenLoc());
7673 Record.push_back(
C->varlist_size());
7674 Record.AddSourceLocation(
C->getLParenLoc());
7675 for (
auto *VE :
C->varlist()) {
7678 for (
auto *VE :
C->private_copies()) {
7684 Record.push_back(
C->varlist_size());
7685 VisitOMPClauseWithPreInit(
C);
7686 Record.AddSourceLocation(
C->getLParenLoc());
7687 for (
auto *VE :
C->varlist()) {
7690 for (
auto *VE :
C->private_copies()) {
7693 for (
auto *VE :
C->inits()) {
7699 Record.push_back(
C->varlist_size());
7700 VisitOMPClauseWithPostUpdate(
C);
7701 Record.AddSourceLocation(
C->getLParenLoc());
7702 Record.writeEnum(
C->getKind());
7703 Record.AddSourceLocation(
C->getKindLoc());
7704 Record.AddSourceLocation(
C->getColonLoc());
7705 for (
auto *VE :
C->varlist())
7707 for (
auto *
E :
C->private_copies())
7709 for (
auto *
E :
C->source_exprs())
7711 for (
auto *
E :
C->destination_exprs())
7713 for (
auto *
E :
C->assignment_ops())
7718 Record.push_back(
C->varlist_size());
7719 Record.AddSourceLocation(
C->getLParenLoc());
7720 for (
auto *VE :
C->varlist())
7725 Record.push_back(
C->varlist_size());
7726 Record.writeEnum(
C->getModifier());
7727 VisitOMPClauseWithPostUpdate(
C);
7728 Record.AddSourceLocation(
C->getLParenLoc());
7729 Record.AddSourceLocation(
C->getModifierLoc());
7730 Record.AddSourceLocation(
C->getColonLoc());
7731 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7732 Record.AddDeclarationNameInfo(
C->getNameInfo());
7733 for (
auto *VE :
C->varlist())
7735 for (
auto *VE :
C->privates())
7737 for (
auto *
E :
C->lhs_exprs())
7739 for (
auto *
E :
C->rhs_exprs())
7741 for (
auto *
E :
C->reduction_ops())
7743 if (
C->getModifier() == clang::OMPC_REDUCTION_inscan) {
7744 for (
auto *
E :
C->copy_ops())
7746 for (
auto *
E :
C->copy_array_temps())
7748 for (
auto *
E :
C->copy_array_elems())
7754 Record.push_back(
C->varlist_size());
7755 VisitOMPClauseWithPostUpdate(
C);
7756 Record.AddSourceLocation(
C->getLParenLoc());
7757 Record.AddSourceLocation(
C->getColonLoc());
7758 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7759 Record.AddDeclarationNameInfo(
C->getNameInfo());
7760 for (
auto *VE :
C->varlist())
7762 for (
auto *VE :
C->privates())
7764 for (
auto *
E :
C->lhs_exprs())
7766 for (
auto *
E :
C->rhs_exprs())
7768 for (
auto *
E :
C->reduction_ops())
7773 Record.push_back(
C->varlist_size());
7774 VisitOMPClauseWithPostUpdate(
C);
7775 Record.AddSourceLocation(
C->getLParenLoc());
7776 Record.AddSourceLocation(
C->getColonLoc());
7777 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7778 Record.AddDeclarationNameInfo(
C->getNameInfo());
7779 for (
auto *VE :
C->varlist())
7781 for (
auto *VE :
C->privates())
7783 for (
auto *
E :
C->lhs_exprs())
7785 for (
auto *
E :
C->rhs_exprs())
7787 for (
auto *
E :
C->reduction_ops())
7789 for (
auto *
E :
C->taskgroup_descriptors())
7794 Record.push_back(
C->varlist_size());
7795 VisitOMPClauseWithPostUpdate(
C);
7796 Record.AddSourceLocation(
C->getLParenLoc());
7797 Record.AddSourceLocation(
C->getColonLoc());
7798 Record.push_back(
C->getModifier());
7799 Record.AddSourceLocation(
C->getModifierLoc());
7800 for (
auto *VE :
C->varlist()) {
7803 for (
auto *VE :
C->privates()) {
7806 for (
auto *VE :
C->inits()) {
7809 for (
auto *VE :
C->updates()) {
7812 for (
auto *VE :
C->finals()) {
7816 Record.AddStmt(
C->getCalcStep());
7817 for (
auto *VE :
C->used_expressions())
7822 Record.push_back(
C->varlist_size());
7823 Record.AddSourceLocation(
C->getLParenLoc());
7824 Record.AddSourceLocation(
C->getColonLoc());
7825 for (
auto *VE :
C->varlist())
7827 Record.AddStmt(
C->getAlignment());
7831 Record.push_back(
C->varlist_size());
7832 Record.AddSourceLocation(
C->getLParenLoc());
7833 for (
auto *VE :
C->varlist())
7835 for (
auto *
E :
C->source_exprs())
7837 for (
auto *
E :
C->destination_exprs())
7839 for (
auto *
E :
C->assignment_ops())
7844 Record.push_back(
C->varlist_size());
7845 Record.AddSourceLocation(
C->getLParenLoc());
7846 for (
auto *VE :
C->varlist())
7848 for (
auto *
E :
C->source_exprs())
7850 for (
auto *
E :
C->destination_exprs())
7852 for (
auto *
E :
C->assignment_ops())
7857 Record.push_back(
C->varlist_size());
7858 Record.AddSourceLocation(
C->getLParenLoc());
7859 for (
auto *VE :
C->varlist())
7864 Record.AddStmt(
C->getDepobj());
7865 Record.AddSourceLocation(
C->getLParenLoc());
7869 Record.push_back(
C->varlist_size());
7870 Record.push_back(
C->getNumLoops());
7871 Record.AddSourceLocation(
C->getLParenLoc());
7872 Record.AddStmt(
C->getModifier());
7873 Record.push_back(
C->getDependencyKind());
7874 Record.AddSourceLocation(
C->getDependencyLoc());
7875 Record.AddSourceLocation(
C->getColonLoc());
7876 Record.AddSourceLocation(
C->getOmpAllMemoryLoc());
7877 for (
auto *VE :
C->varlist())
7879 for (
unsigned I = 0,
E =
C->getNumLoops(); I <
E; ++I)
7880 Record.AddStmt(
C->getLoopData(I));
7884 VisitOMPClauseWithPreInit(
C);
7885 Record.writeEnum(
C->getModifier());
7886 Record.AddStmt(
C->getDevice());
7887 Record.AddSourceLocation(
C->getModifierLoc());
7888 Record.AddSourceLocation(
C->getLParenLoc());
7892 Record.push_back(
C->varlist_size());
7893 Record.push_back(
C->getUniqueDeclarationsNum());
7894 Record.push_back(
C->getTotalComponentListNum());
7895 Record.push_back(
C->getTotalComponentsNum());
7896 Record.AddSourceLocation(
C->getLParenLoc());
7897 bool HasIteratorModifier =
false;
7899 Record.push_back(
C->getMapTypeModifier(I));
7900 Record.AddSourceLocation(
C->getMapTypeModifierLoc(I));
7901 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
7902 HasIteratorModifier =
true;
7904 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7905 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7906 Record.push_back(
C->getMapType());
7907 Record.AddSourceLocation(
C->getMapLoc());
7908 Record.AddSourceLocation(
C->getColonLoc());
7909 for (
auto *
E :
C->varlist())
7911 for (
auto *
E :
C->mapperlists())
7913 if (HasIteratorModifier)
7914 Record.AddStmt(
C->getIteratorModifier());
7915 for (
auto *
D :
C->all_decls())
7917 for (
auto N :
C->all_num_lists())
7919 for (
auto N :
C->all_lists_sizes())
7921 for (
auto &M :
C->all_components()) {
7922 Record.AddStmt(M.getAssociatedExpression());
7923 Record.AddDeclRef(M.getAssociatedDeclaration());
7928 Record.push_back(
C->varlist_size());
7929 Record.writeEnum(
C->getFirstAllocateModifier());
7930 Record.writeEnum(
C->getSecondAllocateModifier());
7931 Record.AddSourceLocation(
C->getLParenLoc());
7932 Record.AddSourceLocation(
C->getColonLoc());
7933 Record.AddStmt(
C->getAllocator());
7934 Record.AddStmt(
C->getAlignment());
7935 for (
auto *VE :
C->varlist())
7940 Record.push_back(
C->varlist_size());
7941 VisitOMPClauseWithPreInit(
C);
7942 Record.AddSourceLocation(
C->getLParenLoc());
7943 for (
auto *VE :
C->varlist())
7948 Record.push_back(
C->varlist_size());
7949 VisitOMPClauseWithPreInit(
C);
7950 Record.AddSourceLocation(
C->getLParenLoc());
7951 for (
auto *VE :
C->varlist())
7956 VisitOMPClauseWithPreInit(
C);
7957 Record.AddStmt(
C->getPriority());
7958 Record.AddSourceLocation(
C->getLParenLoc());
7962 VisitOMPClauseWithPreInit(
C);
7963 Record.writeEnum(
C->getModifier());
7964 Record.AddStmt(
C->getGrainsize());
7965 Record.AddSourceLocation(
C->getModifierLoc());
7966 Record.AddSourceLocation(
C->getLParenLoc());
7970 VisitOMPClauseWithPreInit(
C);
7971 Record.writeEnum(
C->getModifier());
7972 Record.AddStmt(
C->getNumTasks());
7973 Record.AddSourceLocation(
C->getModifierLoc());
7974 Record.AddSourceLocation(
C->getLParenLoc());
7979 Record.AddSourceLocation(
C->getLParenLoc());
7983 VisitOMPClauseWithPreInit(
C);
7984 Record.push_back(
C->getDistScheduleKind());
7985 Record.AddStmt(
C->getChunkSize());
7986 Record.AddSourceLocation(
C->getLParenLoc());
7987 Record.AddSourceLocation(
C->getDistScheduleKindLoc());
7988 Record.AddSourceLocation(
C->getCommaLoc());
7992 Record.push_back(
C->getDefaultmapKind());
7993 Record.push_back(
C->getDefaultmapModifier());
7994 Record.AddSourceLocation(
C->getLParenLoc());
7995 Record.AddSourceLocation(
C->getDefaultmapModifierLoc());
7996 Record.AddSourceLocation(
C->getDefaultmapKindLoc());
7999void OMPClauseWriter::VisitOMPToClause(
OMPToClause *
C) {
8000 Record.push_back(
C->varlist_size());
8001 Record.push_back(
C->getUniqueDeclarationsNum());
8002 Record.push_back(
C->getTotalComponentListNum());
8003 Record.push_back(
C->getTotalComponentsNum());
8004 Record.AddSourceLocation(
C->getLParenLoc());
8006 Record.push_back(
C->getMotionModifier(I));
8007 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
8009 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
8010 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
8011 Record.AddSourceLocation(
C->getColonLoc());
8012 for (
auto *
E :
C->varlist())
8014 for (
auto *
E :
C->mapperlists())
8016 for (
auto *
D :
C->all_decls())
8018 for (
auto N :
C->all_num_lists())
8020 for (
auto N :
C->all_lists_sizes())
8022 for (
auto &M :
C->all_components()) {
8023 Record.AddStmt(M.getAssociatedExpression());
8024 Record.writeBool(M.isNonContiguous());
8025 Record.AddDeclRef(M.getAssociatedDeclaration());
8030 Record.push_back(
C->varlist_size());
8031 Record.push_back(
C->getUniqueDeclarationsNum());
8032 Record.push_back(
C->getTotalComponentListNum());
8033 Record.push_back(
C->getTotalComponentsNum());
8034 Record.AddSourceLocation(
C->getLParenLoc());
8036 Record.push_back(
C->getMotionModifier(I));
8037 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
8039 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
8040 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
8041 Record.AddSourceLocation(
C->getColonLoc());
8042 for (
auto *
E :
C->varlist())
8044 for (
auto *
E :
C->mapperlists())
8046 for (
auto *
D :
C->all_decls())
8048 for (
auto N :
C->all_num_lists())
8050 for (
auto N :
C->all_lists_sizes())
8052 for (
auto &M :
C->all_components()) {
8053 Record.AddStmt(M.getAssociatedExpression());
8054 Record.writeBool(M.isNonContiguous());
8055 Record.AddDeclRef(M.getAssociatedDeclaration());
8060 Record.push_back(
C->varlist_size());
8061 Record.push_back(
C->getUniqueDeclarationsNum());
8062 Record.push_back(
C->getTotalComponentListNum());
8063 Record.push_back(
C->getTotalComponentsNum());
8064 Record.AddSourceLocation(
C->getLParenLoc());
8065 for (
auto *
E :
C->varlist())
8067 for (
auto *VE :
C->private_copies())
8069 for (
auto *VE :
C->inits())
8071 for (
auto *
D :
C->all_decls())
8073 for (
auto N :
C->all_num_lists())
8075 for (
auto N :
C->all_lists_sizes())
8077 for (
auto &M :
C->all_components()) {
8078 Record.AddStmt(M.getAssociatedExpression());
8079 Record.AddDeclRef(M.getAssociatedDeclaration());
8084 Record.push_back(
C->varlist_size());
8085 Record.push_back(
C->getUniqueDeclarationsNum());
8086 Record.push_back(
C->getTotalComponentListNum());
8087 Record.push_back(
C->getTotalComponentsNum());
8088 Record.AddSourceLocation(
C->getLParenLoc());
8089 for (
auto *
E :
C->varlist())
8091 for (
auto *
D :
C->all_decls())
8093 for (
auto N :
C->all_num_lists())
8095 for (
auto N :
C->all_lists_sizes())
8097 for (
auto &M :
C->all_components()) {
8098 Record.AddStmt(M.getAssociatedExpression());
8099 Record.AddDeclRef(M.getAssociatedDeclaration());
8104 Record.push_back(
C->varlist_size());
8105 Record.push_back(
C->getUniqueDeclarationsNum());
8106 Record.push_back(
C->getTotalComponentListNum());
8107 Record.push_back(
C->getTotalComponentsNum());
8108 Record.AddSourceLocation(
C->getLParenLoc());
8109 for (
auto *
E :
C->varlist())
8111 for (
auto *
D :
C->all_decls())
8113 for (
auto N :
C->all_num_lists())
8115 for (
auto N :
C->all_lists_sizes())
8117 for (
auto &M :
C->all_components()) {
8118 Record.AddStmt(M.getAssociatedExpression());
8119 Record.AddDeclRef(M.getAssociatedDeclaration());
8124 Record.push_back(
C->varlist_size());
8125 Record.push_back(
C->getUniqueDeclarationsNum());
8126 Record.push_back(
C->getTotalComponentListNum());
8127 Record.push_back(
C->getTotalComponentsNum());
8128 Record.AddSourceLocation(
C->getLParenLoc());
8129 for (
auto *
E :
C->varlist())
8131 for (
auto *
D :
C->all_decls())
8133 for (
auto N :
C->all_num_lists())
8135 for (
auto N :
C->all_lists_sizes())
8137 for (
auto &M :
C->all_components()) {
8138 Record.AddStmt(M.getAssociatedExpression());
8139 Record.AddDeclRef(M.getAssociatedDeclaration());
8145void OMPClauseWriter::VisitOMPUnifiedSharedMemoryClause(
8154void OMPClauseWriter::VisitOMPAtomicDefaultMemOrderClause(
8156 Record.push_back(
C->getAtomicDefaultMemOrderKind());
8157 Record.AddSourceLocation(
C->getLParenLoc());
8158 Record.AddSourceLocation(
C->getAtomicDefaultMemOrderKindKwLoc());
8161void OMPClauseWriter::VisitOMPAtClause(
OMPAtClause *
C) {
8162 Record.push_back(
C->getAtKind());
8163 Record.AddSourceLocation(
C->getLParenLoc());
8164 Record.AddSourceLocation(
C->getAtKindKwLoc());
8168 Record.push_back(
C->getSeverityKind());
8169 Record.AddSourceLocation(
C->getLParenLoc());
8170 Record.AddSourceLocation(
C->getSeverityKindKwLoc());
8174 Record.AddStmt(
C->getMessageString());
8175 Record.AddSourceLocation(
C->getLParenLoc());
8179 Record.push_back(
C->varlist_size());
8180 Record.AddSourceLocation(
C->getLParenLoc());
8181 for (
auto *VE :
C->varlist())
8183 for (
auto *
E :
C->private_refs())
8188 Record.push_back(
C->varlist_size());
8189 Record.AddSourceLocation(
C->getLParenLoc());
8190 for (
auto *VE :
C->varlist())
8195 Record.push_back(
C->varlist_size());
8196 Record.AddSourceLocation(
C->getLParenLoc());
8197 for (
auto *VE :
C->varlist())
8202 Record.writeEnum(
C->getKind());
8203 Record.writeEnum(
C->getModifier());
8204 Record.AddSourceLocation(
C->getLParenLoc());
8205 Record.AddSourceLocation(
C->getKindKwLoc());
8206 Record.AddSourceLocation(
C->getModifierKwLoc());
8210 Record.push_back(
C->getNumberOfAllocators());
8211 Record.AddSourceLocation(
C->getLParenLoc());
8212 for (
unsigned I = 0,
E =
C->getNumberOfAllocators(); I <
E; ++I) {
8222 Record.push_back(
C->varlist_size());
8223 Record.AddSourceLocation(
C->getLParenLoc());
8224 Record.AddStmt(
C->getModifier());
8225 Record.AddSourceLocation(
C->getColonLoc());
8226 for (
Expr *
E :
C->varlist())
8231 Record.writeEnum(
C->getBindKind());
8232 Record.AddSourceLocation(
C->getLParenLoc());
8233 Record.AddSourceLocation(
C->getBindKindLoc());
8237 VisitOMPClauseWithPreInit(
C);
8239 Record.AddSourceLocation(
C->getLParenLoc());
8243 Record.push_back(
C->varlist_size());
8244 Record.push_back(
C->getNumLoops());
8245 Record.AddSourceLocation(
C->getLParenLoc());
8246 Record.push_back(
C->getDependenceType());
8247 Record.AddSourceLocation(
C->getDependenceLoc());
8248 Record.AddSourceLocation(
C->getColonLoc());
8249 for (
auto *VE :
C->varlist())
8251 for (
unsigned I = 0,
E =
C->getNumLoops(); I <
E; ++I)
8252 Record.AddStmt(
C->getLoopData(I));
8256 Record.AddAttributes(
C->getAttrs());
8257 Record.AddSourceLocation(
C->getBeginLoc());
8258 Record.AddSourceLocation(
C->getLParenLoc());
8259 Record.AddSourceLocation(
C->getEndLoc());
8266 for (
const auto &
Set : TI->
Sets) {
8273 writeExprRef(
Selector.ScoreOrCondition);
8287 for (
unsigned I = 0,
E =
Data->getNumClauses(); I <
E; ++I)
8289 if (
Data->hasAssociatedStmt())
8291 for (
unsigned I = 0,
E =
Data->getNumChildren(); I <
E; ++I)
8297 for (
Expr *
E :
C->getVarList())
8303 for (
Expr *
E : Exprs)
8312 switch (
C->getClauseKind()) {
8314 const auto *DC = cast<OpenACCDefaultClause>(
C);
8320 const auto *IC = cast<OpenACCIfClause>(
C);
8322 AddStmt(
const_cast<Expr*
>(IC->getConditionExpr()));
8326 const auto *SC = cast<OpenACCSelfClause>(
C);
8329 if (SC->isConditionExprClause()) {
8331 if (SC->hasConditionExpr())
8332 AddStmt(
const_cast<Expr *
>(SC->getConditionExpr()));
8335 for (
Expr *
E : SC->getVarList())
8341 const auto *NGC = cast<OpenACCNumGangsClause>(
C);
8344 for (
Expr *
E : NGC->getIntExprs())
8349 const auto *DNC = cast<OpenACCDeviceNumClause>(
C);
8355 const auto *DAC = cast<OpenACCDefaultAsyncClause>(
C);
8361 const auto *NWC = cast<OpenACCNumWorkersClause>(
C);
8367 const auto *NWC = cast<OpenACCVectorLengthClause>(
C);
8373 const auto *PC = cast<OpenACCPrivateClause>(
C);
8379 const auto *HC = cast<OpenACCHostClause>(
C);
8385 const auto *DC = cast<OpenACCDeviceClause>(
C);
8391 const auto *FPC = cast<OpenACCFirstPrivateClause>(
C);
8397 const auto *AC = cast<OpenACCAttachClause>(
C);
8403 const auto *DC = cast<OpenACCDetachClause>(
C);
8409 const auto *DC = cast<OpenACCDeleteClause>(
C);
8415 const auto *UDC = cast<OpenACCUseDeviceClause>(
C);
8421 const auto *DPC = cast<OpenACCDevicePtrClause>(
C);
8427 const auto *NCC = cast<OpenACCNoCreateClause>(
C);
8433 const auto *PC = cast<OpenACCPresentClause>(
C);
8441 const auto *CC = cast<OpenACCCopyClause>(
C);
8449 const auto *CIC = cast<OpenACCCopyInClause>(
C);
8458 const auto *COC = cast<OpenACCCopyOutClause>(
C);
8467 const auto *CC = cast<OpenACCCreateClause>(
C);
8474 const auto *AC = cast<OpenACCAsyncClause>(
C);
8477 if (AC->hasIntExpr())
8482 const auto *WC = cast<OpenACCWaitClause>(
C);
8485 if (
Expr *DNE = WC->getDevNumExpr())
8494 const auto *DTC = cast<OpenACCDeviceTypeClause>(
C);
8506 const auto *RC = cast<OpenACCReductionClause>(
C);
8521 const auto *CC = cast<OpenACCCollapseClause>(
C);
8528 const auto *TC = cast<OpenACCTileClause>(
C);
8531 for (
Expr *
E : TC->getSizeExprs())
8536 const auto *GC = cast<OpenACCGangClause>(
C);
8539 for (
unsigned I = 0; I < GC->getNumExprs(); ++I) {
8541 AddStmt(
const_cast<Expr *
>(GC->getExpr(I).second));
8546 const auto *WC = cast<OpenACCWorkerClause>(
C);
8549 if (WC->hasIntExpr())
8554 const auto *VC = cast<OpenACCVectorClause>(
C);
8557 if (VC->hasIntExpr())
8567 llvm_unreachable(
"Clause serialization not yet implemented");
8569 llvm_unreachable(
"Invalid Clause Kind");
Defines the clang::ASTContext interface.
static bool isInterestingIdentifier(ASTReader &Reader, const IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
static NamedDecl * getDeclForLocalLookup(const LangOptions &LangOpts, NamedDecl *D)
Determine the declaration that should be put into the name lookup table to represent the given declar...
static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream)
Create an abbreviation for the SLocEntry that refers to a buffer.
static bool isLookupResultNotInteresting(ASTWriter &Writer, StoredDeclsList &Result)
Returns ture if all of the lookup result are either external, not emitted or predefined.
static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec)
static bool IsInternalDeclFromFileContext(const Decl *D)
static TypeID MakeTypeID(ASTContext &Context, QualType T, IdxForTypeTy IdxForType)
static void AddLazyVectorEmiitedDecls(ASTWriter &Writer, Vector &Vec, ASTWriter::RecordData &Record)
static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream)
Create an abbreviation for the SLocEntry that refers to a macro expansion.
static StringRef bytes(const std::vector< T, Allocator > &v)
static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream, bool Compressed)
Create an abbreviation for the SLocEntry that refers to a buffer's blob.
static void BackpatchSignatureAt(llvm::BitstreamWriter &Stream, const ASTFileSignature &S, uint64_t BitNo)
static const char * adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir)
Adjusts the given filename to only write out the portion of the filename that is not part of the syst...
static bool isLocalIdentifierID(IdentifierID ID)
If the.
static unsigned getNumberOfModules(Module *Mod)
Compute the number of modules within the given tree (including the given module).
static bool isImportedDeclContext(ASTReader *Chain, const Decl *D)
static TypeCode getTypeCodeForTypeClass(Type::TypeClass id)
static void AddStmtsExprs(llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record)
static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob, unsigned SLocBufferBlobCompressedAbbrv, unsigned SLocBufferBlobAbbrv)
static uint64_t EmitCXXBaseSpecifiers(ASTContext &Context, ASTWriter &W, ArrayRef< CXXBaseSpecifier > Bases)
static std::pair< unsigned, unsigned > emitULEBKeyDataLength(unsigned KeyLen, unsigned DataLen, raw_ostream &Out)
Emit key length and data length as ULEB-encoded data, and return them as a pair.
static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule, const Preprocessor &PP)
static bool cleanPathForOutput(FileManager &FileMgr, SmallVectorImpl< char > &Path)
Prepares a path for being written to an AST file by converting it to an absolute path and removing ne...
static uint64_t EmitCXXCtorInitializers(ASTContext &Context, ASTWriter &W, ArrayRef< CXXCtorInitializer * > CtorInits)
static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream)
Create an abbreviation for the SLocEntry that refers to a file.
Defines the Diagnostic-related interfaces.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines interfaces for clang::FileEntry and clang::FileEntryRef.
Defines the clang::FileManager interface and associated types.
Defines the clang::FileSystemOptions interface.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the LambdaCapture class.
Defines several types used to describe C++ lambda expressions that are shared between the parser and ...
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::Target Target
llvm::MachO::Record Record
Defines the clang::MacroInfo and clang::MacroDirective classes.
Defines the clang::Module class, which describes a module in the source code.
Defines types useful for describing an Objective-C runtime.
Defines some OpenACC-specific enums and functions.
Defines the clang::OpenCLOptions class.
This file defines OpenMP AST classes for clauses.
Defines the clang::Preprocessor interface.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for Objective-C.
static void EmitBlockID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, RecordDataImpl &Record)
Emits a block ID in the BLOCKINFO block.
static void EmitRecordID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, RecordDataImpl &Record)
Emits a record ID in the BLOCKINFO block.
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.
#define IMPORT(DERIVED, BASE)
#define BLOCK(DERIVED, BASE)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
Defines version macros and version-related utility functions for Clang.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
DeclarationNameTable DeclarationNames
QualType getRawCFConstantStringType() const
Get the structure type used to representation CFStrings, or NULL if it hasn't yet been built.
QualType getucontext_tType() const
Retrieve the C ucontext_t type.
QualType getRecordType(const RecordDecl *Decl) const
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getFILEType() const
Retrieve the C FILE type.
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
const LangOptions & getLangOpts() const
RawCommentList Comments
All comments in this translation unit.
QualType getjmp_bufType() const
Retrieve the C jmp_buf type.
QualType getsigjmp_bufType() const
Retrieve the C sigjmp_buf type.
QualType AutoRRefDeductTy
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
FunctionDecl * getcudaConfigureCallDecl()
import_range local_imports() const
Reads an AST files chain containing the contents of a translation unit.
ModuleManager & getModuleManager()
Retrieve the module manager.
const serialization::reader::DeclContextLookupTable * getLoadedLookupTables(DeclContext *Primary) const
Get the loaded lookup tables for Primary, if any.
unsigned getTotalNumSubmodules() const
Returns the number of submodules known.
void finalizeForWriting()
Finalizes the AST reader's state before writing an AST file to disk.
void forEachImportedKeyDecl(const Decl *D, Fn Visit)
Run a callback on each imported key declaration of D.
unsigned getTotalNumSelectors() const
Returns the number of selectors found in the chain.
unsigned getModuleFileID(ModuleFile *M)
Get an ID for the given module file.
Decl * getKeyDeclaration(Decl *D)
Returns the first key declaration for the given declaration.
void LoadSelector(Selector Sel)
Load a selector from disk, registering its ID if it exists.
bool isProcessingUpdateRecords()
serialization::reader::LazySpecializationInfoLookupTable * getLoadedSpecializationsLookupTables(const Decl *D, bool IsPartial)
Get the loaded specializations lookup tables for D, if any.
unsigned getTotalNumMacros() const
Returns the number of macros found in the chain.
An object for streaming information to a record.
void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo)
void AddCXXBaseSpecifiers(ArrayRef< CXXBaseSpecifier > Bases)
Emit a set of C++ base specifiers.
void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs)
Emit a template argument list.
uint64_t Emit(unsigned Code, unsigned Abbrev=0)
Emit the record to the stream, followed by its substatements, and return its offset.
void AddCXXTemporary(const CXXTemporary *Temp)
Emit a CXXTemporary.
void writeOMPTraitInfo(const OMPTraitInfo *TI)
Write an OMPTraitInfo object.
void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base)
Emit a C++ base specifier.
void writeOMPClause(OMPClause *C)
void writeBool(bool Value)
void AddAPValue(const APValue &Value)
Emit an APvalue.
void AddUnresolvedSet(const ASTUnresolvedSet &Set)
Emit a UnresolvedSet structure.
void AddIdentifierRef(const IdentifierInfo *II)
Emit a reference to an identifier.
void AddStmt(Stmt *S)
Add the given statement or expression to the queue of statements to emit.
void AddDeclarationName(DeclarationName Name)
Emit a declaration name.
void AddSelectorRef(Selector S)
Emit a Selector (which is a smart pointer reference).
void AddSourceRange(SourceRange Range, LocSeq *Seq=nullptr)
Emit a source range.
void writeSourceLocation(SourceLocation Loc)
void AddOffset(uint64_t BitOffset)
Add a bit offset into the record.
void AddTypeRef(QualType T)
Emit a reference to a type.
void writeQualType(QualType T)
void writeOpenACCClauseList(ArrayRef< const OpenACCClause * > Clauses)
Writes out a list of OpenACC clauses.
void AddSourceLocation(SourceLocation Loc, LocSeq *Seq=nullptr)
Emit a source location.
void push_back(uint64_t N)
Minimal vector-like interface.
void AddTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Emits source location information for a type. Does not emit the type.
void AddCXXCtorInitializers(ArrayRef< CXXCtorInitializer * > CtorInits)
Emit a CXXCtorInitializer array.
void AddTemplateParameterList(const TemplateParameterList *TemplateParams)
Emit a template parameter list.
void AddTemplateArgument(const TemplateArgument &Arg)
Emit a template argument.
void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name)
void writeOpenACCIntExprList(ArrayRef< Expr * > Exprs)
void AddAPFloat(const llvm::APFloat &Value)
Emit a floating-point value.
void AddTypeSourceInfo(TypeSourceInfo *TInfo)
Emits a reference to a declarator info.
void AddQualifierInfo(const QualifierInfo &Info)
void writeUInt32(uint32_t Value)
void AddDeclRef(const Decl *D)
Emit a reference to a declaration.
void writeOMPChildren(OMPChildren *Data)
Writes data related to the OpenMP directives.
void AddConceptReference(const ConceptReference *CR)
void AddAPInt(const llvm::APInt &Value)
Emit an integral value.
void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg)
Emits a template argument location info.
void writeOpenACCVarList(const OpenACCClauseWithVarList *C)
void AddAttributes(ArrayRef< const Attr * > Attrs)
Emit a list of attributes.
void AddASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *ASTTemplArgList)
Emits an AST template argument list info.
void AddCXXDefinitionData(const CXXRecordDecl *D)
void AddVarDeclInit(const VarDecl *VD)
Emit information about the initializer of a VarDecl.
void writeStmtRef(const Stmt *S)
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg)
Emits a template argument location.
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)
Emit a nested name specifier with source-location information.
void writeOpenACCClause(const OpenACCClause *C)
Writes out a single OpenACC Clause.
void AddAttr(const Attr *A)
An UnresolvedSet-like class which uses the ASTContext's allocator.
Writes an AST file containing the contents of a translation unit.
serialization::MacroID getMacroID(MacroInfo *MI)
Determine the ID of an already-emitted macro.
void AddEmittedDeclRef(const Decl *D, RecordDataImpl &Record)
void AddSourceRange(SourceRange Range, RecordDataImpl &Record, LocSeq *Seq=nullptr)
Emit a source range.
bool isWritingStdCXXNamedModules() const
void EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, StringRef Path)
Emit the current record with the given path as a blob.
void AddFileID(FileID FID, RecordDataImpl &Record)
Emit a FileID.
bool isDeclPredefined(const Decl *D) const
void AddPath(StringRef Path, RecordDataImpl &Record)
Add a path to the given record.
unsigned getTypeExtQualAbbrev() const
void AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record)
Add a version tuple to the given record.
bool isGeneratingReducedBMI() const
uint32_t getMacroDirectivesOffset(const IdentifierInfo *Name)
void AddAlignPackInfo(const Sema::AlignPackInfo &Info, RecordDataImpl &Record)
Emit a AlignPackInfo.
void AddPathBlob(StringRef Str, RecordDataImpl &Record, SmallVectorImpl< char > &Blob)
bool IsLocalDecl(const Decl *D)
Is this a local declaration (that is, one that will be written to our AST file)? This is the case for...
void AddTypeRef(ASTContext &Context, QualType T, RecordDataImpl &Record)
Emit a reference to a type.
bool wasDeclEmitted(const Decl *D) const
Whether or not the declaration got emitted.
void AddString(StringRef Str, RecordDataImpl &Record)
Add a string to the given record.
time_t getTimestampForOutput(const FileEntry *E) const
Get a timestamp for output into the AST file.
bool isWritingModule() const
LocalDeclID GetDeclRef(const Decl *D)
Force a declaration to be emitted and get its local ID to the module file been writing.
LocalDeclID getDeclID(const Decl *D)
Determine the local declaration ID of an already-emitted declaration.
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
serialization::MacroID getMacroRef(MacroInfo *MI, const IdentifierInfo *Name)
Get the unique number used to refer to the given macro.
void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record, LocSeq *Seq=nullptr)
Emit a source location.
ASTFileSignature WriteAST(llvm::PointerUnion< Sema *, Preprocessor * > Subject, StringRef OutputFile, Module *WritingModule, StringRef isysroot, bool ShouldCacheASTInMemory=false)
Write a precompiled header or a module with the AST produced by the Sema object, or a dependency scan...
ASTReader * getChain() const
bool getDoneWritingDeclsAndTypes() const
serialization::IdentifierID getIdentifierRef(const IdentifierInfo *II)
Get the unique number used to refer to the given identifier.
void handleVTable(CXXRecordDecl *RD)
unsigned getLocalOrImportedSubmoduleID(const Module *Mod)
Retrieve or create a submodule ID for this module, or return 0 if the submodule is neither local (a s...
void AddToken(const Token &Tok, RecordDataImpl &Record)
Emit a token.
serialization::SelectorID getSelectorRef(Selector Sel)
Get the unique number used to refer to the given selector.
SourceLocationEncoding::RawLocEncoding getRawSourceLocationEncoding(SourceLocation Loc, LocSeq *Seq=nullptr)
Return the raw encodings for source locations.
ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl< char > &Buffer, InMemoryModuleCache &ModuleCache, ArrayRef< std::shared_ptr< ModuleFileExtension > > Extensions, bool IncludeTimestamps=true, bool BuildingImplicitModule=false, bool GeneratingReducedBMI=false)
Create a new precompiled header writer that outputs to the given bitstream.
SmallVector< uint64_t, 64 > RecordData
serialization::TypeID GetOrCreateTypeID(ASTContext &Context, QualType T)
Force a type to be emitted and get its ID.
unsigned getAnonymousDeclarationNumber(const NamedDecl *D)
const LangOptions & getLangOpts() const
void SetSelectorOffset(Selector Sel, uint32_t Offset)
Note that the selector Sel occurs at the given offset within the method pool/selector table.
bool PreparePathForOutput(SmallVectorImpl< char > &Path)
Convert a path from this build process into one that is appropriate for emission in the module file.
void SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset)
Note that the identifier II occurs at the given offset within the identifier table.
void AddDeclRef(const Decl *D, RecordDataImpl &Record)
Emit a reference to a declaration.
void AddStringBlob(StringRef Str, RecordDataImpl &Record, SmallVectorImpl< char > &Blob)
Wrapper for source info for array parameter types.
Wrapper for source info for arrays.
SourceLocation getLBracketLoc() const
Expr * getSizeExpr() const
SourceLocation getRBracketLoc() const
SourceLocation getRParenLoc() const
SourceLocation getKWLoc() const
SourceLocation getLParenLoc() const
Attr - This represents one attribute.
attr::Kind getKind() const
SourceLocation getScopeLoc() const
SourceRange getRange() const
const IdentifierInfo * getScopeName() const
bool isRegularKeywordAttribute() const
const IdentifierInfo * getAttrName() const
Kind getParsedKind() const
Type source information for an attributed type.
const Attr * getAttr() const
The type attribute.
SourceLocation getRParenLoc() const
bool isDecltypeAuto() const
bool isConstrained() const
ConceptReference * getConceptReference() const
Type source information for an btf_tag attributed type.
A simple helper class to pack several bits in order into (a) 32 bit integer(s).
void addBits(uint32_t Value, uint32_t BitsWidth)
Wrapper for source info for block pointers.
SourceLocation getCaretLoc() const
Wrapper for source info for builtin types.
SourceLocation getBuiltinLoc() const
TypeSpecifierType getWrittenTypeSpec() const
TypeSpecifierWidth getWrittenWidthSpec() const
bool needsExtraLocalData() const
TypeSpecifierSign getWrittenSignSpec() const
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
Represents a C++ temporary.
const CXXDestructorDecl * getDestructor() const
Declaration of a class template.
Represents a class template specialization, which refers to a class template with a given set of temp...
A reference to a concept and its template args, as it appears in the code.
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
NamedDecl * getFoundDecl() const
const DeclarationNameInfo & getConceptNameInfo() const
ConceptDecl * getNamedConcept() const
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
SourceLocation getTemplateKWLoc() const
Wrapper for source info for pointers decayed from arrays and functions.
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isFileContext() const
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool isLookupContext() const
Test whether the context supports looking up names.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
StoredDeclsMap * buildLookup()
Ensure the lookup structure is fully-built and return it.
lookup_result noload_lookup(DeclarationName Name)
Find the declarations with the given name that are visible within this context; don't attempt to retr...
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
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.
bool isFunctionOrMethod() const
StoredDeclsMap * getLookupPtr() const
Retrieve the internal representation of the lookup structure.
DeclID getRawValue() const
A helper iterator adaptor to convert the iterators to SmallVector<SomeDeclID> to the iterators to Sma...
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isInNamedModule() const
Whether this declaration comes from a named module.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
@ FOK_None
Not a friend object.
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
bool isFromExplicitGlobalModule() const
Whether this declaration comes from explicit global module.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
SourceLocation getLocation() const
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
GlobalDeclID getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
DeclarationNameLoc - Additional source/type location info for a declaration name.
SourceLocation getCXXLiteralOperatorNameLoc() const
Return the location of the literal operator name (without the operator keyword).
TypeSourceInfo * getNamedTypeInfo() const
Returns the source type info.
SourceRange getCXXOperatorNameRange() const
Return the range of the operator name (without the operator keyword).
The name of a declaration.
@ CXXConversionFunctionName
SourceLocation getDecltypeLoc() const
SourceLocation getRParenLoc() const
SourceLocation getTemplateNameLoc() const
Expr * getAttrExprOperand() const
The attribute's expression operand, if it has one.
SourceRange getAttrOperandParensRange() const
The location of the parentheses around the operand, if there is an operand.
SourceLocation getAttrNameLoc() const
The location of the attribute name, i.e.
NestedNameSpecifierLoc getQualifierLoc() const
SourceLocation getNameLoc() const
SourceLocation getElaboratedKeywordLoc() const
SourceLocation getNameLoc() const
unsigned getNumArgs() const
SourceLocation getTemplateNameLoc() const
SourceLocation getLAngleLoc() const
SourceLocation getTemplateKeywordLoc() const
TemplateArgumentLoc getArgLoc(unsigned i) const
SourceLocation getRAngleLoc() const
SourceLocation getElaboratedKeywordLoc() const
NestedNameSpecifierLoc getQualifierLoc() const
SourceLocation getNameLoc() const
static DiagnosticMapping getDefaultMapping(unsigned DiagID)
Get the default mapping for this diagnostic.
Options for controlling the compiler diagnostics engine.
std::vector< std::string > Remarks
The list of -R... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > Warnings
The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.
Concrete class used by the front-end to report problems and issues.
StringRef getName() const
SourceLocation getElaboratedKeywordLoc() const
NestedNameSpecifierLoc getQualifierLoc() const
Wrapper for source info for enum types.
This represents one expression.
Represents difference between two FPOptions values.
storage_type getAsOpaqueInt() const
storage_type getAsOpaqueInt() const
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...
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.
void trackVFSUsage(bool Active)
Enable or disable tracking of VFS usage.
llvm::vfs::FileSystem & getVirtualFileSystem() const
void GetUniqueIDMapping(SmallVectorImpl< OptionalFileEntryRef > &UIDToFiles) const
Produce an array mapping from the unique IDs assigned to each file to the corresponding FileEntryRef.
bool makeAbsolutePath(SmallVectorImpl< char > &Path) const
Makes Path absolute taking into account FileSystemOptions and the working directory option.
FileSystemOptions & getFileSystemOpts()
Returns the current file system options.
OptionalDirectoryEntryRef getOptionalDirectoryRef(StringRef DirName, bool CacheFailure=true)
Get a DirectoryEntryRef if it exists, without doing anything on error.
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.
Represents a prototype with parameter type info, e.g.
Declaration of a template function.
Wrapper for source info for functions.
unsigned getNumParams() const
ParmVarDecl * getParam(unsigned i) const
SourceLocation getLocalRangeEnd() const
SourceRange getExceptionSpecRange() const
SourceLocation getLocalRangeBegin() const
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
Type source information for HLSL attributed resource type.
One of these records is kept for each identifier that is lexed.
unsigned getLength() const
Efficiently return the length of this identifier info.
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
bool hasChangedSinceDeserialization() const
Determine whether this identifier has changed since it was loaded from an AST file.
bool isCPlusPlusOperatorKeyword() const
bool hasFETokenInfoChangedSinceDeserialization() const
Determine whether the frontend token information for this identifier has changed since it was loaded ...
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.
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
tok::NotableIdentifierKind getNotableIdentifierID() const
unsigned getObjCOrBuiltinID() const
tok::ObjCKeywordKind getObjCKeywordID() const
Return the Objective-C keyword ID for the this identifier.
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.
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
iterator begin(DeclarationName Name)
Returns an iterator over decls with the name 'Name'.
iterator end()
Returns the end iterator.
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.
In-memory cache for modules.
llvm::MemoryBuffer & addBuiltPCM(llvm::StringRef Filename, std::unique_ptr< llvm::MemoryBuffer > Buffer)
Store a just-built PCM under the Filename.
Wrapper for source info for injected class names of class templates.
SourceLocation getAmpLoc() const
Describes the capture of a variable or of this, or of a C++1y init-capture.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
clang::ObjCRuntime ObjCRuntime
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 ...
Used to hold and unique data used to represent #line information.
Record the location of a macro definition.
Encapsulates changes to the "macros namespace" (the location where the macro name became active,...
const MacroDirective * getPrevious() const
Get previous definition of the macro with the same name.
const MacroInfo * getMacroInfo() const
SourceLocation getLocation() const
Encapsulates the data about a macro definition (e.g.
bool isUsed() const
Return false if this macro is defined in the main file and has not yet been used.
bool isC99Varargs() const
SourceLocation getDefinitionEndLoc() const
Return the location of the last token in the macro.
ArrayRef< const IdentifierInfo * > params() const
unsigned getNumTokens() const
Return the number of tokens that this macro expands to.
unsigned getNumParams() const
const Token & getReplacementToken(unsigned Tok) const
bool isBuiltinMacro() const
Return true if this macro requires processing before expansion.
SourceLocation getDefinitionLoc() const
Return the location that the macro was defined at.
bool hasCommaPasting() const
bool isObjectLike() const
bool isUsedForHeaderGuard() const
Determine whether this macro was used for a header guard.
bool isGNUVarargs() const
SourceLocation getExpansionLoc() const
Expr * getAttrColumnOperand() const
The attribute's column operand, if it has one.
SourceRange getAttrOperandParensRange() const
The location of the parentheses around the operand, if there is an operand.
SourceLocation getAttrNameLoc() const
The location of the attribute name, i.e.
Expr * getAttrRowOperand() const
The attribute's row operand, if it has one.
Wrapper for source info for member pointers.
TypeSourceInfo * getClassTInfo() const
SourceLocation getStarLoc() const
Abstract base class that writes a module file extension block into a module file.
virtual void writeExtensionContents(Sema &SemaRef, llvm::BitstreamWriter &Stream)=0
Write the contents of the extension block into the given bitstream.
ModuleFileExtension * getExtension() const
Retrieve the module file extension with which this writer is associated.
virtual ModuleFileExtensionMetadata getExtensionMetadata() const =0
Retrieves the metadata for this module file extension.
void resolveHeaderDirectives(const FileEntry *File) const
Resolve all lazy header directives for the specified file.
ArrayRef< KnownHeader > findResolvedModulesForHeader(FileEntryRef File) const
Like findAllModulesForHeader, but do not attempt to infer module ownership from umbrella headers if w...
FileID getModuleMapFileIDForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module.
FileID getContainingModuleMapFileID(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
ModuleHeaderRole
Flags describing the role of a module header.
static ModuleHeaderRole headerKindToRole(Module::HeaderKind Kind)
Convert a header kind to a role. Requires Kind to not be HK_Excluded.
Describes a module or submodule.
unsigned IsExplicit
Whether this is an explicit submodule.
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
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...
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.
Module * Parent
The parent of this module.
ModuleKind Kind
The kind of this module.
bool isUnimportable() const
Determine whether this module has been declared unimportable.
unsigned IsInferred
Whether this is an inferred submodule (module * { ... }).
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
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.
llvm::iterator_range< submodule_iterator > submodules()
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.
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.
llvm::SmallSetVector< const Module *, 2 > UndeclaredUses
When NoUndeclaredIncludes is true, the set of modules this module tried to import but didn't because ...
OptionalDirectoryEntryRef Directory
The build directory of this module.
unsigned NamedModuleHasInit
Whether this C++20 named modules doesn't need an initializer.
llvm::SmallSetVector< Module *, 2 > AffectingClangModules
The set of top-level modules that affected the compilation of this module, but were not imported.
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.
ArrayRef< Header > getHeaders(HeaderKind HK) const
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e....
ArrayRef< FileEntryRef > getTopHeaders(FileManager &FileMgr)
The top-level headers associated with this module.
std::optional< DirectoryName > getUmbrellaDirAsWritten() const
Retrieve the umbrella directory as written.
bool isHeaderUnit() const
Is this module a header unit.
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
unsigned IsFramework
Whether this is a framework module.
std::string ExportAsModule
The module through which entities defined in this module will eventually be exposed,...
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
bool isNamedModule() const
Does this Module is a named module of a standard named module?
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
std::vector< Conflict > Conflicts
The list of conflicts.
This represents a decl that may have a name.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
SourceRange getLocalSourceRange() const
Retrieve the source range covering just the last part of this nested-name-specifier,...
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
SpecifierKind
The kind of specifier that completes this nested name specifier.
@ 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*.
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
This represents the 'absent' clause in the '#pragma omp assume' directive.
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.
This represents the 'align' clause in the '#pragma omp allocate' directive.
This represents clause 'aligned' in the '#pragma omp ...' directives.
This represents clause 'allocate' in the '#pragma omp ...' directives.
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.
This represents 'capture' clause in the '#pragma omp atomic' directive.
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc.
Class that handles pre-initialization statement for some clauses, like 'schedule',...
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 the 'contains' clause in the '#pragma omp assume' directive.
This represents clause 'copyin' in the '#pragma omp ...' directives.
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
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.
This represents implicit clause 'depobj' for the '#pragma omp depobj' directive.
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.
This represents 'dynamic_allocators' clause in the '#pragma omp requires' directive.
This represents clause 'exclusive' in the '#pragma omp scan' directive.
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.
This represents implicit clause 'flush' for the '#pragma omp flush' directive.
This represents clause 'from' in the '#pragma omp ...' directives.
Representation of the 'full' clause of the '#pragma omp unroll' directive.
This represents 'grainsize' clause in the '#pragma omp ...' directive.
This represents clause 'has_device_ptr' in the '#pragma omp ...' directives.
This represents 'hint' clause in the '#pragma omp ...' directive.
This represents the 'holds' clause in the '#pragma omp assume' directive.
This represents 'if' clause in the '#pragma omp ...' directive.
This represents clause 'in_reduction' in the '#pragma omp task' directives.
This represents clause 'inclusive' in the '#pragma omp scan' directive.
This represents the 'init' clause in '#pragma omp ...' directives.
This represents clause 'is_device_ptr' in the '#pragma omp ...' directives.
This represents clause 'lastprivate' in the '#pragma omp ...' directives.
This represents clause 'linear' in the '#pragma omp ...' directives.
This represents clause 'map' in the '#pragma omp ...' directives.
This represents 'mergeable' clause in the '#pragma omp ...' directive.
This represents 'message' clause in the '#pragma omp error' directive.
This represents the 'no_openmp' clause in the '#pragma omp assume' directive.
This represents the 'no_openmp_routines' clause in the '#pragma omp assume' directive.
This represents the 'no_parallelism' clause in the '#pragma omp assume' 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.
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.
Representation of the 'partial' clause of the '#pragma omp unroll' directive.
This class represents the 'permutation' clause in the '#pragma omp interchange' directive.
This represents 'priority' clause in the '#pragma omp ...' directive.
This represents clause 'private' in the '#pragma omp ...' directives.
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.
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|flush' directives.
This represents 'severity' clause in the '#pragma omp error' directive.
This represents clause 'shared' in the '#pragma omp ...' directives.
This represents 'simdlen' clause in the '#pragma omp ...' directive.
This represents the 'sizes' clause in the '#pragma omp tile' directive.
This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives.
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.
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.
This represents the 'use' clause in '#pragma omp ...' directives.
This represents clause 'use_device_addr' in the '#pragma omp ...' directives.
This represents clause 'use_device_ptr' in the '#pragma omp ...' directives.
This represents clause 'uses_allocators' in the '#pragma omp target'-based directives.
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.
ObjCCategoryDecl - Represents a category declaration.
Iterator that walks over the list of categories, filtering out those that do not meet specific criter...
Represents an ObjC class declaration.
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Wrapper for source info for ObjC interfaces.
SourceLocation getNameEndLoc() const
SourceLocation getNameLoc() const
Wraps an ObjCPointerType with source location information.
SourceLocation getStarLoc() const
bool hasBaseTypeAsWritten() const
SourceLocation getTypeArgsLAngleLoc() const
unsigned getNumTypeArgs() const
unsigned getNumProtocols() const
TypeSourceInfo * getTypeArgTInfo(unsigned i) const
SourceLocation getProtocolRAngleLoc() const
SourceLocation getProtocolLoc(unsigned i) const
SourceLocation getProtocolLAngleLoc() const
SourceLocation getTypeArgsRAngleLoc() const
const VersionTuple & getVersion() const
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
unsigned getNumProtocols() const
SourceLocation getProtocolLoc(unsigned i) const
SourceLocation getProtocolLAngleLoc() const
SourceLocation getProtocolRAngleLoc() const
Represents a clause with one or more 'var' objects, represented as an expr, as its arguments.
This is the base type for all OpenACC Clauses.
OpenCL supported extensions and optional core features.
SourceLocation getEllipsisLoc() const
SourceLocation getEllipsisLoc() const
SourceLocation getRParenLoc() const
SourceLocation getLParenLoc() const
Represents a parameter to a function.
SourceLocation getKWLoc() const
Wrapper for source info for pointers.
SourceLocation getStarLoc() const
Iteration over the preprocessed entities.
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
MacroDefinitionRecord * findMacroDefinition(const MacroInfo *MI)
Retrieve the macro definition that corresponds to the given MacroInfo.
const std::vector< SourceRange > & getSkippedRanges()
Retrieve all ranges that got skipped while preprocessing.
iterator local_begin()
Begin iterator for local, non-loaded, preprocessed entities.
iterator local_end()
End iterator for local, non-loaded, preprocessed entities.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::string > MacroIncludes
std::vector< std::string > Includes
bool WriteCommentListToPCH
Whether to write comment locations into the PCH when building it.
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
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 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.
ArrayRef< ModuleMacro * > getLeafModuleMacros(const IdentifierInfo *II) const
Get the list of leaf (non-overridden) module macros for a name.
ArrayRef< PPConditionalInfo > getPreambleConditionalStack() const
SourceLocation getModuleImportLoc(Module *M) const
bool isRecordingPreamble() const
MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const
Given an identifier, return the latest non-imported macro directive for that identifier.
bool SawDateOrTime() const
Returns true if the preprocessor has seen a use of DATE or TIME in the file so far.
unsigned getCounterValue() const
SourceManager & getSourceManager() const
std::optional< PreambleSkipInfo > getPreambleSkipInfo() const
bool hasRecordedPreamble() const
const TargetInfo & getTargetInfo() const
FileManager & getFileManager() const
PreprocessorOptions & getPreprocessorOpts() const
Retrieve the preprocessor options used to initialize this preprocessor.
bool alreadyIncluded(FileEntryRef File) const
Return true if this header has already been included.
FileID getPredefinesFileID() const
Returns the FileID for the preprocessor predefines.
HeaderSearch & getHeaderSearchInfo() const
SmallVector< SourceLocation, 64 > serializeSafeBufferOptOutMap() const
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
PreprocessingRecord * getPreprocessingRecord() const
Retrieve the preprocessing record, or NULL if there is no preprocessing record.
DiagnosticsEngine & getDiagnostics() const
SourceLocation getPreambleRecordedPragmaAssumeNonNullLoc() const
Get the location of the recorded unterminated #pragma clang assume_nonnull begin in the preamble,...
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
A (possibly-)qualified type.
Wrapper of type source information for a type with non-trivial direct qualifiers.
The collection of all-type qualifiers we support.
SourceLocation getAmpAmpLoc() const
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...
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Smart pointer class that efficiently represents Objective-C method names.
const IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
void * getAsOpaquePtr() const
unsigned getNumArgs() const
void updateOutOfDateSelector(Selector Sel)
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
static uint32_t getRawEncoding(const AlignPackInfo &Info)
Sema - This implements semantic analysis and AST building for C.
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
DelegatingCtorDeclsType DelegatingCtorDecls
All the delegating constructors seen so far in the file, used for cycle detection at the end of the T...
Preprocessor & getPreprocessor() const
PragmaStack< FPOptionsOverride > FpPragmaStack
ExtVectorDeclsType ExtVectorDecls
ExtVectorDecls - This is a list all the extended vector types.
SourceLocation getOptimizeOffPragmaLocation() const
Get the location for the currently active "\#pragma clang optimize off". If this location is invalid,...
FPOptionsOverride CurFPFeatureOverrides()
LateParsedTemplateMapT LateParsedTemplateMap
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used.
SmallVector< const Decl * > DeclsWithEffectsToVerify
All functions/lambdas/blocks which have bodies and which have a non-empty FunctionEffectsRef to be ve...
EnumDecl * getStdAlignValT() const
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
SmallVector< VTableUse, 16 > VTableUses
The list of vtables that are required but have not yet been materialized.
llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate > > LateParsedTemplateMapT
CXXRecordDecl * getStdBadAlloc() const
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
llvm::DenseMap< CXXRecordDecl *, bool > VTablesUsed
The set of classes whose vtables have been used within this translation unit, and a bit that will be ...
PragmaStack< AlignPackInfo > AlignPackStack
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
const llvm::MapVector< FieldDecl *, DeleteLocs > & getMismatchingDeleteExpressions() const
Retrieves list of suspicious delete-expressions that will be checked at the end of translation unit.
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
llvm::MapVector< IdentifierInfo *, llvm::SetVector< WeakInfo, llvm::SmallVector< WeakInfo, 1u >, llvm::SmallDenseSet< WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly > > > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
IdentifierResolver IdResolver
static RawLocEncoding encode(SourceLocation Loc, UIntTy BaseOffset, unsigned BaseModuleFileIndex, SourceLocationSequence *=nullptr)
This object establishes a SourceLocationSequence.
Serialized encoding of a sequence of SourceLocations.
Encodes a location in the source.
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.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
DiagnosticsEngine & getDiagnostics() const
SourceLocation::UIntTy getNextLocalOffset() const
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
const SrcMgr::SLocEntry & getLocalSLocEntry(unsigned Index) const
Get a local SLocEntry. This is exposed for indexing.
FileManager & getFileManager() const
unsigned local_sloc_entry_size() const
Get the number of local SLocEntries we have.
SourceLocation getLocForEndOfFile(FileID FID) const
Return the source location corresponding to the last byte of the specified file.
FileID getMainFileID() const
Returns the FileID of the main source file.
unsigned getFileIDSize(FileID FID) const
The size of the SLocEntry that FID represents.
bool hasLineTable() const
Determine if the source manager has a line table.
bool isLoadedSourceLocation(SourceLocation Loc) const
Returns true if Loc came from a PCH/Module.
bool isLoadedFileID(FileID FID) const
Returns true if FID came from a PCH/Module.
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file.
LineTableInfo & getLineTable()
Retrieve the stored line table.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
One instance of this struct is kept for every file loaded or used.
OptionalFileEntryRef ContentsEntry
References the file which the contents were actually loaded from.
unsigned IsTransient
True if this file may be transient, that is, if it might not exist at some later point in time when t...
std::optional< llvm::MemoryBufferRef > getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM, SourceLocation Loc=SourceLocation()) const
Returns the memory buffer for the associated content.
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.
Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded,...
SourceLocation getExpansionLocStart() const
bool isExpansionTokenRange() const
SourceLocation getSpellingLoc() const
bool isMacroArgExpansion() const
SourceLocation getExpansionLocEnd() const
Information about a FileID, basically just the logical file that it represents and include stack info...
const ContentCache & getContentCache() const
This is a discriminated union of FileInfo and ExpansionInfo.
SourceLocation::UIntTy getOffset() const
const FileInfo & getFile() const
const ExpansionInfo & getExpansion() const
An array of decls optimized for the common case of only containing one entry.
Wrapper for substituted template type parameters.
Wrapper for substituted template type parameters.
Represents the declaration of a struct/union/class/enum.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Exposes information about the current target.
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 template argument list.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
Location wrapper for a TemplateArgument.
TemplateArgumentLocInfo getLocInfo() const
const TemplateArgument & getArgument() const
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.
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
SourceLocation getTemplateLoc() const
unsigned getNumArgs() const
SourceLocation getLAngleLoc() const
TemplateArgumentLoc getArgLoc(unsigned i) const
SourceLocation getRAngleLoc() const
SourceLocation getTemplateNameLoc() const
SourceLocation getTemplateKeywordLoc() const
Wrapper for template type parameters.
Token - This structure provides full information about a lexed token.
IdentifierInfo * getIdentifierInfo() const
unsigned getFlags() const
Return the internal represtation of the flags.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
unsigned getLength() const
SourceLocation getAnnotationEndLoc() const
void * getAnnotationValue() const
tok::TokenKind getKind() const
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
The top declaration context.
NamespaceDecl * getAnonymousNamespace() const
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
TypeSourceInfo * getUnmodifiedTInfo() const
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
SourceLocation getNameLoc() const
The base class of the type hierarchy.
TypeClass getTypeClass() const
Base class for declarations which introduce a typedef-name.
Wrapper for source info for typedefs.
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
SourceLocation getTypeofLoc() const
The iterator over UnresolvedSets.
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.
EvaluatedStmt * getEvaluatedStmt() const
const Expr * getInit() const
APValue * getEvaluatedValue() const
Return the already-evaluated value of this variable's initializer, or NULL if the value is not yet kn...
Declaration of a variable template.
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getNameLoc() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
SourceLocation getEllipsisLoc() const
Retrieve the source location of the ellipsis, whose presence indicates that the capture is a pack exp...
void writeQualifiers(Qualifiers value)
A key used when looking up entities by DeclarationName.
Information about a module that has been loaded by the ASTReader.
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
serialization::SelectorID BaseSelectorID
Base selector ID for selectors local to this module.
unsigned LocalNumSubmodules
The number of submodules in this module.
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
unsigned NumPreprocessedEntities
unsigned Index
The index of this module in the list of modules.
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
std::string FileName
The file name of the module file.
SourceLocation::UIntTy SLocEntryBaseOffset
The base offset in the source manager's view of this module.
unsigned LocalNumMacros
The number of macros in this AST file.
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.
Writer for the on-disk hash table.
A type index; the type ID with the qualifier bits removed.
uint32_t getModuleFileIndex() const
TypeID asTypeID(unsigned FastQuals) const
uint64_t getValue() const
Class that performs name lookup into a DeclContext stored in an AST file.
Class that performs lookup to specialized decls.
const unsigned int LOCAL_REDECLARATIONS
Record code for a list of local redeclarations of a declaration.
TypeCode
Record codes for each kind of type.
const unsigned int DECL_UPDATES
Record of updates for a declaration that was modified after being deserialized.
@ PREDEF_TYPE_AUTO_RREF_DEDUCT
The "auto &&" deduction type.
@ PREDEF_TYPE_NULL_ID
The NULL type.
@ PREDEF_TYPE_AUTO_DEDUCT
The "auto" deduction type.
@ CTOR_INITIALIZER_MEMBER
@ CTOR_INITIALIZER_DELEGATING
@ CTOR_INITIALIZER_INDIRECT_MEMBER
@ DECL_EMPTY
An EmptyDecl record.
@ DECL_CXX_BASE_SPECIFIERS
A record containing CXXBaseSpecifiers.
@ DECL_CXX_RECORD
A CXXRecordDecl record.
@ DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION
A VarTemplatePartialSpecializationDecl record.
@ DECL_OMP_ALLOCATE
An OMPAllocateDcl record.
@ DECL_MS_PROPERTY
A MSPropertyDecl record.
@ DECL_REQUIRES_EXPR_BODY
A RequiresExprBodyDecl record.
@ DECL_STATIC_ASSERT
A StaticAssertDecl record.
@ DECL_INDIRECTFIELD
A IndirectFieldDecl record.
@ DECL_TEMPLATE_TEMPLATE_PARM
A TemplateTemplateParmDecl record.
@ DECL_IMPORT
An ImportDecl recording a module import.
@ DECL_ACCESS_SPEC
An AccessSpecDecl record.
@ DECL_OBJC_TYPE_PARAM
An ObjCTypeParamDecl record.
@ DECL_OBJC_CATEGORY_IMPL
A ObjCCategoryImplDecl record.
@ DECL_ENUM_CONSTANT
An EnumConstantDecl record.
@ DECL_PARM_VAR
A ParmVarDecl record.
@ DECL_TYPEDEF
A TypedefDecl record.
@ DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK
A TemplateTemplateParmDecl record that stores an expanded template template parameter pack.
@ DECL_HLSL_BUFFER
A HLSLBufferDecl record.
@ DECL_NAMESPACE_ALIAS
A NamespaceAliasDecl record.
@ DECL_TYPEALIAS
A TypeAliasDecl record.
@ DECL_FUNCTION_TEMPLATE
A FunctionTemplateDecl record.
@ DECL_UNRESOLVED_USING_TYPENAME
An UnresolvedUsingTypenameDecl record.
@ DECL_CLASS_TEMPLATE_SPECIALIZATION
A ClassTemplateSpecializationDecl record.
@ DECL_FILE_SCOPE_ASM
A FileScopeAsmDecl record.
@ DECL_PARTIAL_SPECIALIZATIONS
@ DECL_CXX_CONSTRUCTOR
A CXXConstructorDecl record.
@ DECL_CXX_CONVERSION
A CXXConversionDecl record.
@ DECL_FIELD
A FieldDecl record.
@ DECL_LINKAGE_SPEC
A LinkageSpecDecl record.
@ DECL_NAMESPACE
A NamespaceDecl record.
@ DECL_NON_TYPE_TEMPLATE_PARM
A NonTypeTemplateParmDecl record.
@ DECL_FUNCTION
A FunctionDecl record.
@ DECL_USING_DIRECTIVE
A UsingDirecitveDecl record.
@ DECL_RECORD
A RecordDecl record.
@ DECL_CONTEXT_LEXICAL
A record that stores the set of declarations that are lexically stored within a given DeclContext.
@ DECL_BLOCK
A BlockDecl record.
@ DECL_UNRESOLVED_USING_VALUE
An UnresolvedUsingValueDecl record.
@ DECL_TYPE_ALIAS_TEMPLATE
A TypeAliasTemplateDecl record.
@ DECL_CXX_CTOR_INITIALIZERS
A record containing CXXCtorInitializers.
@ DECL_OBJC_CATEGORY
A ObjCCategoryDecl record.
@ DECL_VAR
A VarDecl record.
@ DECL_USING
A UsingDecl record.
@ DECL_OBJC_PROTOCOL
A ObjCProtocolDecl record.
@ DECL_TEMPLATE_TYPE_PARM
A TemplateTypeParmDecl record.
@ DECL_VAR_TEMPLATE_SPECIALIZATION
A VarTemplateSpecializationDecl record.
@ DECL_OBJC_IMPLEMENTATION
A ObjCImplementationDecl record.
@ DECL_OBJC_COMPATIBLE_ALIAS
A ObjCCompatibleAliasDecl record.
@ DECL_FRIEND_TEMPLATE
A FriendTemplateDecl record.
@ DECL_PRAGMA_DETECT_MISMATCH
A PragmaDetectMismatchDecl record.
@ DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK
A NonTypeTemplateParmDecl record that stores an expanded non-type template parameter pack.
@ DECL_OBJC_AT_DEFS_FIELD
A ObjCAtDefsFieldDecl record.
@ DECL_IMPLICIT_PARAM
An ImplicitParamDecl record.
@ DECL_FRIEND
A FriendDecl record.
@ DECL_CXX_METHOD
A CXXMethodDecl record.
@ DECL_EXPORT
An ExportDecl record.
@ DECL_PRAGMA_COMMENT
A PragmaCommentDecl record.
@ DECL_ENUM
An EnumDecl record.
@ DECL_OMP_DECLARE_REDUCTION
An OMPDeclareReductionDecl record.
@ DECL_OMP_THREADPRIVATE
An OMPThreadPrivateDecl record.
@ DECL_OBJC_METHOD
A ObjCMethodDecl record.
@ DECL_CXX_DESTRUCTOR
A CXXDestructorDecl record.
@ DECL_OMP_CAPTUREDEXPR
An OMPCapturedExprDecl record.
@ DECL_CLASS_TEMPLATE
A ClassTemplateDecl record.
@ DECL_USING_SHADOW
A UsingShadowDecl record.
@ DECL_CONCEPT
A ConceptDecl record.
@ DECL_OBJC_IVAR
A ObjCIvarDecl record.
@ DECL_OBJC_PROPERTY
A ObjCPropertyDecl record.
@ DECL_OBJC_INTERFACE
A ObjCInterfaceDecl record.
@ DECL_VAR_TEMPLATE
A VarTemplateDecl record.
@ DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION
A ClassTemplatePartialSpecializationDecl record.
@ DECL_CONTEXT_VISIBLE
A record that stores the set of declarations that are visible from a given DeclContext.
@ DECL_OBJC_PROPERTY_IMPL
A ObjCPropertyImplDecl record.
@ TYPE_EXT_QUAL
An ExtQualType record.
@ EXPR_DESIGNATED_INIT
A DesignatedInitExpr record.
@ EXPR_COMPOUND_LITERAL
A CompoundLiteralExpr record.
@ EXPR_OBJC_IVAR_REF_EXPR
An ObjCIvarRefExpr record.
@ EXPR_MEMBER
A MemberExpr record.
@ EXPR_CXX_TEMPORARY_OBJECT
A CXXTemporaryObjectExpr record.
@ EXPR_CXX_UNRESOLVED_LOOKUP
@ EXPR_COMPOUND_ASSIGN_OPERATOR
A CompoundAssignOperator record.
@ EXPR_EXPR_WITH_CLEANUPS
@ EXPR_CXX_STATIC_CAST
A CXXStaticCastExpr record.
@ EXPR_OBJC_STRING_LITERAL
An ObjCStringLiteral record.
@ EXPR_VA_ARG
A VAArgExpr record.
@ EXPR_CXX_OPERATOR_CALL
A CXXOperatorCallExpr record.
@ STMT_OBJC_AT_TRY
An ObjCAtTryStmt record.
@ EXPR_CXX_UNRESOLVED_CONSTRUCT
@ EXPR_FIXEDPOINT_LITERAL
@ STMT_DO
A DoStmt record.
@ STMT_OBJC_CATCH
An ObjCAtCatchStmt record.
@ STMT_IF
An IfStmt record.
@ EXPR_CXX_EXPRESSION_TRAIT
@ EXPR_STRING_LITERAL
A StringLiteral record.
@ EXPR_IMPLICIT_CAST
An ImplicitCastExpr record.
@ STMT_GCCASM
A GCC-style AsmStmt record.
@ EXPR_IMAGINARY_LITERAL
An ImaginaryLiteral record.
@ STMT_WHILE
A WhileStmt record.
@ EXPR_STMT
A StmtExpr record.
@ EXPR_CXX_REINTERPRET_CAST
A CXXReinterpretCastExpr record.
@ EXPR_DESIGNATED_INIT_UPDATE
A DesignatedInitUpdateExpr record.
@ STMT_OBJC_AT_SYNCHRONIZED
An ObjCAtSynchronizedStmt record.
@ EXPR_CXX_PSEUDO_DESTRUCTOR
@ EXPR_CHARACTER_LITERAL
A CharacterLiteral record.
@ EXPR_OBJC_ENCODE
An ObjCEncodeExpr record.
@ EXPR_CSTYLE_CAST
A CStyleCastExpr record.
@ EXPR_OBJC_BOXED_EXPRESSION
@ EXPR_OBJC_BOOL_LITERAL
An ObjCBoolLiteralExpr record.
@ EXPR_CXX_BIND_TEMPORARY
@ EXPR_EXT_VECTOR_ELEMENT
An ExtVectorElementExpr record.
@ STMT_RETURN
A ReturnStmt record.
@ STMT_OBJC_FOR_COLLECTION
An ObjCForCollectionStmt record.
@ STMT_CONTINUE
A ContinueStmt record.
@ EXPR_PREDEFINED
A PredefinedExpr record.
@ EXPR_CXX_BOOL_LITERAL
A CXXBoolLiteralExpr record.
@ EXPR_PAREN_LIST
A ParenListExpr record.
@ EXPR_CXX_PAREN_LIST_INIT
A CXXParenListInitExpr record.
@ STMT_COMPOUND
A CompoundStmt record.
@ STMT_FOR
A ForStmt record.
@ STMT_ATTRIBUTED
An AttributedStmt record.
@ EXPR_CXX_REWRITTEN_BINARY_OPERATOR
A CXXRewrittenBinaryOperator record.
@ STMT_GOTO
A GotoStmt record.
@ EXPR_NO_INIT
An NoInitExpr record.
@ EXPR_OBJC_ARRAY_LITERAL
@ EXPR_OBJC_PROTOCOL_EXPR
An ObjCProtocolExpr record.
@ EXPR_CXX_CONSTRUCT
A CXXConstructExpr record.
@ EXPR_OBJC_DICTIONARY_LITERAL
@ EXPR_CXX_DYNAMIC_CAST
A CXXDynamicCastExpr record.
@ STMT_CXX_TRY
A CXXTryStmt record.
@ EXPR_GENERIC_SELECTION
A GenericSelectionExpr record.
@ EXPR_CALL
A CallExpr record.
@ EXPR_GNU_NULL
A GNUNullExpr record.
@ EXPR_BINARY_CONDITIONAL_OPERATOR
@ EXPR_OBJC_PROPERTY_REF_EXPR
An ObjCPropertyRefExpr record.
@ EXPR_CXX_CONST_CAST
A CXXConstCastExpr record.
@ STMT_REF_PTR
A reference to a previously [de]serialized Stmt record.
@ EXPR_OBJC_MESSAGE_EXPR
An ObjCMessageExpr record.
@ EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
@ STMT_CASE
A CaseStmt record.
@ EXPR_FUNCTION_PARM_PACK
@ STMT_STOP
A marker record that indicates that we are at the end of an expression.
@ EXPR_CXX_NULL_PTR_LITERAL
@ STMT_MSASM
A MS-style AsmStmt record.
@ EXPR_CONDITIONAL_OPERATOR
A ConditionOperator record.
@ EXPR_BINARY_OPERATOR
A BinaryOperator record.
@ EXPR_CXX_STD_INITIALIZER_LIST
A CXXStdInitializerListExpr record.
@ EXPR_SHUFFLE_VECTOR
A ShuffleVectorExpr record.
@ STMT_OBJC_FINALLY
An ObjCAtFinallyStmt record.
@ EXPR_OBJC_SELECTOR_EXPR
An ObjCSelectorExpr record.
@ EXPR_FLOATING_LITERAL
A FloatingLiteral record.
@ EXPR_CXX_DEPENDENT_SCOPE_MEMBER
@ STMT_NULL_PTR
A NULL expression.
@ STMT_DEFAULT
A DefaultStmt record.
@ EXPR_CHOOSE
A ChooseExpr record.
@ STMT_NULL
A NullStmt record.
@ EXPR_DECL_REF
A DeclRefExpr record.
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM
@ EXPR_INIT_LIST
An InitListExpr record.
@ EXPR_IMPLICIT_VALUE_INIT
An ImplicitValueInitExpr record.
@ EXPR_PAREN
A ParenExpr record.
@ STMT_LABEL
A LabelStmt record.
@ EXPR_CXX_FUNCTIONAL_CAST
A CXXFunctionalCastExpr record.
@ EXPR_USER_DEFINED_LITERAL
A UserDefinedLiteral record.
@ EXPR_INTEGER_LITERAL
An IntegerLiteral record.
@ EXPR_MATERIALIZE_TEMPORARY
@ EXPR_CXX_MEMBER_CALL
A CXXMemberCallExpr record.
@ STMT_SWITCH
A SwitchStmt record.
@ STMT_DECL
A DeclStmt record.
@ EXPR_CXX_UNRESOLVED_MEMBER
@ EXPR_OBJC_KVC_REF_EXPR
UNUSED.
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
@ EXPR_CXX_SCALAR_VALUE_INIT
@ EXPR_SIZEOF_ALIGN_OF
A SizefAlignOfExpr record.
@ STMT_BREAK
A BreakStmt record.
@ STMT_OBJC_AT_THROW
An ObjCAtThrowStmt record.
@ EXPR_ADDR_LABEL
An AddrLabelExpr record.
@ STMT_CXX_FOR_RANGE
A CXXForRangeStmt record.
@ EXPR_CXX_ADDRSPACE_CAST
A CXXAddrspaceCastExpr record.
@ EXPR_ARRAY_SUBSCRIPT
An ArraySubscriptExpr record.
@ EXPR_UNARY_OPERATOR
A UnaryOperator record.
@ STMT_CXX_CATCH
A CXXCatchStmt record.
@ STMT_INDIRECT_GOTO
An IndirectGotoStmt record.
Defines the clang::TargetInfo interface.
bool isSystem(CharacteristicKind CK)
Determine whether a file / directory characteristic is for system code.
bool isModuleMap(CharacteristicKind CK)
Determine whether a file characteristic is for a module map.
bool LE(InterpState &S, CodePtr OpPC)
GlobalDeclID LazySpecializationInfo
uint64_t TypeID
An ID number that refers to a type in an AST file.
@ EXTENSION_METADATA
Metadata describing this particular extension.
@ 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.
TypeIdx TypeIdxFromBuiltin(const BuiltinType *BT)
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.
@ 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.
unsigned StableHashForTemplateArguments(llvm::ArrayRef< TemplateArgument > Args)
Calculate a stable hash value for template arguments.
const unsigned VERSION_MINOR
AST file minor version number supported by this version of Clang.
@ SM_SLOC_FILE_ENTRY
Describes a source location entry (SLocEntry) for a file.
@ SM_SLOC_BUFFER_BLOB_COMPRESSED
Describes a zlib-compressed blob that contains the data for a buffer entry.
@ SM_SLOC_BUFFER_ENTRY
Describes a source location entry (SLocEntry) for a buffer.
@ SM_SLOC_BUFFER_BLOB
Describes a blob that contains the data for a buffer entry.
@ SM_SLOC_EXPANSION_ENTRY
Describes a source location entry (SLocEntry) for a macro expansion.
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
DeclIDBase::DeclID DeclID
An ID number that refers to a declaration in an AST file.
@ 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.
void numberAnonymousDeclsWithin(const DeclContext *DC, Fn Visit)
Visit each declaration within DC that needs an anonymous declaration number and call Visit with the d...
@ 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.
@ 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...
@ 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.
@ INPUT_FILE_HASH
The input file content hash.
@ INPUT_FILE
An input file.
const DeclContext * getDefinitiveDeclContext(const DeclContext *DC)
Retrieve the "definitive" declaration that provides all of the visible entries for the given declarat...
void updateModuleTimestamp(StringRef ModuleFilename)
@ 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.
uint64_t IdentifierID
An ID number that refers to an identifier in an AST file.
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
@ 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.
@ CXX_ADDED_TEMPLATE_SPECIALIZATION
@ 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.
@ PP_UNSAFE_BUFFER_USAGE
Record code for #pragma clang unsafe_buffer_usage begin/end.
@ CXX_ADDED_TEMPLATE_PARTIAL_SPECIALIZATION
@ DECLS_WITH_EFFECTS_TO_VERIFY
Record code for Sema's vector of functions/blocks with effects to be verified.
@ 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.
@ RELATED_DECLS_MAP
Record code for related declarations that have to be deserialized together from the same module.
@ 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.
@ OPENCL_EXTENSION_DECLS
Record code for declarations associated with OpenCL extensions.
@ VTABLES_TO_EMIT
Record code for vtables to emit.
@ IDENTIFIER_OFFSET
Record code for the table of offsets of each identifier ID.
@ OBJC_CATEGORIES
Record code for the array of Objective-C categories (including extensions).
@ METHOD_POOL
Record code for the Objective-C method pool,.
@ DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD
Record code for lexical and visible block for delayed namespace in reduced BMI.
@ PP_CONDITIONAL_STACK
The stack of open #ifs/#ifdefs recorded in a preamble.
@ REFERENCED_SELECTOR_POOL
Record code for referenced selector pool.
@ SOURCE_LOCATION_OFFSETS
Record code for the table of offsets into the block of source-location information.
@ WEAK_UNDECLARED_IDENTIFIERS
Record code for weak undeclared identifiers.
@ UNDEFINED_BUT_USED
Record code for undefined but used functions and variables that need a definition in this TU.
@ FILE_SORTED_DECLS
Record code for a file sorted array of DeclIDs in a module.
@ MSSTRUCT_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
@ TENTATIVE_DEFINITIONS
Record code for the array of tentative definitions.
@ UNUSED_FILESCOPED_DECLS
Record code for the array of unused file scoped decls.
@ ALIGN_PACK_PRAGMA_OPTIONS
Record code for #pragma align/pack options.
@ IMPORTED_MODULES
Record code for an array of all of the (sub)modules that were imported by the AST file.
@ SELECTOR_OFFSETS
Record code for the table of offsets into the Objective-C method pool.
@ UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES
Record code for potentially unused local typedef names.
@ OPENCL_EXTENSION_TYPES
Record code for types associated with OpenCL extensions.
@ 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...
@ METADATA_OLD_FORMAT
This is so that older clang versions, before the introduction of the control block,...
@ 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.
unsigned ComputeHash(Selector Sel)
@ UPD_CXX_RESOLVED_DTOR_DELETE
@ UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER
@ UPD_CXX_DEDUCED_RETURN_TYPE
@ UPD_CXX_ADDED_IMPLICIT_MEMBER
@ UPD_DECL_MARKED_OPENMP_DECLARETARGET
@ UPD_CXX_POINT_OF_INSTANTIATION
@ UPD_CXX_RESOLVED_EXCEPTION_SPEC
@ UPD_CXX_ADDED_FUNCTION_DEFINITION
@ UPD_DECL_MARKED_OPENMP_THREADPRIVATE
@ UPD_STATIC_LOCAL_NUMBER
@ UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT
@ UPD_ADDED_ATTR_TO_RECORD
@ UPD_DECL_MARKED_OPENMP_ALLOCATE
@ UPD_CXX_ADDED_ANONYMOUS_NAMESPACE
@ UPD_CXX_INSTANTIATED_CLASS_DEFINITION
@ UPD_CXX_ADDED_VAR_DEFINITION
The JSON file list parser is used to communicate input to InstallAPI.
@ NUM_OVERLOADED_OPERATORS
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
@ LCK_ByCopy
Capturing by copy (a.k.a., by value)
@ LCK_ByRef
Capturing by reference.
@ LCK_VLAType
Capturing variable-length array type.
@ LCK_StarThis
Capturing the *this object by copy.
@ LCK_This
Capturing the *this object by reference.
@ Auto
'auto' clause, allowed on 'loop' directives.
@ Bind
'bind' clause, allowed on routine constructs.
@ Gang
'gang' clause, allowed on 'loop' and Combined constructs.
@ Wait
'wait' clause, allowed on Compute, Data, 'update', and Combined constructs.
@ DevicePtr
'deviceptr' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ PCopyOut
'copyout' clause alias 'pcopyout'. Preserved for diagnostic purposes.
@ VectorLength
'vector_length' clause, allowed on 'parallel', 'kernels', 'parallel loop', and 'kernels loop' constru...
@ Async
'async' clause, allowed on Compute, Data, 'update', 'wait', and Combined constructs.
@ PresentOrCreate
'create' clause alias 'present_or_create'.
@ Collapse
'collapse' clause, allowed on 'loop' and Combined constructs.
@ NoHost
'nohost' clause, allowed on 'routine' directives.
@ PresentOrCopy
'copy' clause alias 'present_or_copy'. Preserved for diagnostic purposes.
@ DeviceNum
'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
@ Invalid
Represents an invalid clause, for the purposes of parsing.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Copy
'copy' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ Worker
'worker' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ DeviceType
'device_type' clause, allowed on Compute, 'data', 'init', 'shutdown', 'set', update',...
@ DefaultAsync
'default_async' clause, allowed on 'set' construct.
@ Attach
'attach' clause, allowed on Compute and Combined constructs, plus 'data' and 'enter data'.
@ NumGangs
'num_gangs' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs.
@ If
'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...
@ Default
'default' clause, allowed on parallel, serial, kernel (and compound) constructs.
@ UseDevice
'use_device' clause, allowed on 'host_data' construct.
@ NoCreate
'no_create' clause, allowed on allowed on Compute and Combined constructs, plus 'data'.
@ PresentOrCopyOut
'copyout' clause alias 'present_or_copyout'.
@ Link
'link' clause, allowed on 'declare' construct.
@ Reduction
'reduction' clause, allowed on Parallel, Serial, Loop, and the combined constructs.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ CopyOut
'copyout' clause, allowed on Compute and Combined constructs, plus 'data', 'exit data',...
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ FirstPrivate
'firstprivate' clause, allowed on 'parallel', 'serial', 'parallel loop', and 'serial loop' constructs...
@ Host
'host' clause, allowed on 'update' construct.
@ PCopy
'copy' clause alias 'pcopy'. Preserved for diagnostic purposes.
@ Tile
'tile' clause, allowed on 'loop' and Combined constructs.
@ PCopyIn
'copyin' clause alias 'pcopyin'. Preserved for diagnostic purposes.
@ DeviceResident
'device_resident' clause, allowed on the 'declare' construct.
@ PCreate
'create' clause alias 'pcreate'. Preserved for diagnostic purposes.
@ Present
'present' clause, allowed on Compute and Combined constructs, plus 'data' and 'declare'.
@ DType
'dtype' clause, an alias for 'device_type', stored separately for diagnostic purposes.
@ CopyIn
'copyin' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ Device
'device' clause, allowed on the 'update' construct.
@ Independent
'independent' clause, allowed on 'loop' directives.
@ NumWorkers
'num_workers' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs...
@ IfPresent
'if_present' clause, allowed on 'host_data' and 'update' directives.
@ Detach
'detach' clause, allowed on the 'exit data' construct.
@ Delete
'delete' clause, allowed on the 'exit data' construct.
@ PresentOrCopyIn
'copyin' clause alias 'present_or_copyin'.
@ Finalize
'finalize' clause, allowed on 'exit data' directive.
static constexpr unsigned NumberOfOMPMapClauseModifiers
Number of allowed map-type-modifiers.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
PredefinedDeclIDs
Predefined declaration IDs.
@ PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID
The internal '__NSConstantString' tag type.
@ PREDEF_DECL_COMMON_TYPE_ID
The internal '__builtin_common_type' template.
@ PREDEF_DECL_TRANSLATION_UNIT_ID
The translation unit.
@ PREDEF_DECL_TYPE_PACK_ELEMENT_ID
The internal '__type_pack_element' template.
@ PREDEF_DECL_OBJC_CLASS_ID
The Objective-C 'Class' type.
@ PREDEF_DECL_BUILTIN_MS_GUID_ID
The predeclared '_GUID' struct.
@ PREDEF_DECL_OBJC_INSTANCETYPE_ID
The internal 'instancetype' typedef.
@ PREDEF_DECL_OBJC_PROTOCOL_ID
The Objective-C 'Protocol' type.
@ PREDEF_DECL_UNSIGNED_INT_128_ID
The unsigned 128-bit integer type.
@ PREDEF_DECL_OBJC_SEL_ID
The Objective-C 'SEL' type.
@ PREDEF_DECL_INT_128_ID
The signed 128-bit integer type.
@ PREDEF_DECL_VA_LIST_TAG
The internal '__va_list_tag' struct, if any.
@ PREDEF_DECL_BUILTIN_MS_VA_LIST_ID
The internal '__builtin_ms_va_list' typedef.
@ PREDEF_DECL_CF_CONSTANT_STRING_ID
The internal '__NSConstantString' typedef.
@ PREDEF_DECL_BUILTIN_VA_LIST_ID
The internal '__builtin_va_list' typedef.
@ PREDEF_DECL_EXTERN_C_CONTEXT_ID
The extern "C" context.
@ PREDEF_DECL_OBJC_ID_ID
The Objective-C 'id' type.
@ PREDEF_DECL_MAKE_INTEGER_SEQ_ID
The internal '__make_integer_seq' template.
@ Property
The type of a property.
@ Result
The result type of a method or function.
bool CanElideDeclDef(const Decl *D)
If we can elide the definition of.
std::pair< IdentifierInfo *, SourceLocation > DeviceTypeArgument
static constexpr unsigned NumberOfOMPMotionModifiers
Number of allowed motion-modifiers.
for(const auto &A :T->param_types())
const FunctionProtoType * T
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
@ None
The alignment was not explicit in code.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
Diagnostic wrappers for TextAPI types for error reporting.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
The signature of a module, which is a hash of the AST content.
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>".
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments.
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
const DeclarationNameLoc & getInfo() const
Structure used to store a statement, the constant value to which it was evaluated (if any),...
Contains a late templated function.
FPOptions FPO
Floating-point options in the point of definition.
Decl * D
The template function declaration to be late parsed.
Data for list of allocators.
a linked list of methods with the same selector name but different signatures.
ObjCMethodList * getNext() const
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.
Location information for a TemplateArgument.
SourceLocation getTemplateEllipsisLoc() const
NestedNameSpecifierLoc getTemplateQualifierLoc() const
TypeSourceInfo * getAsTypeSourceInfo() const
SourceLocation getTemplateNameLoc() const
Describes the categories of an Objective-C class.