74#include "llvm/ADT/APFloat.h"
75#include "llvm/ADT/APInt.h"
76#include "llvm/ADT/APSInt.h"
77#include "llvm/ADT/ArrayRef.h"
78#include "llvm/ADT/DenseMap.h"
79#include "llvm/ADT/Hashing.h"
80#include "llvm/ADT/PointerIntPair.h"
81#include "llvm/ADT/STLExtras.h"
82#include "llvm/ADT/ScopeExit.h"
83#include "llvm/ADT/SmallPtrSet.h"
84#include "llvm/ADT/SmallString.h"
85#include "llvm/ADT/SmallVector.h"
86#include "llvm/ADT/StringMap.h"
87#include "llvm/ADT/StringRef.h"
88#include "llvm/Bitstream/BitCodes.h"
89#include "llvm/Bitstream/BitstreamWriter.h"
90#include "llvm/Support/Casting.h"
91#include "llvm/Support/Compression.h"
92#include "llvm/Support/DJB.h"
93#include "llvm/Support/Endian.h"
94#include "llvm/Support/EndianStream.h"
95#include "llvm/Support/Error.h"
96#include "llvm/Support/ErrorHandling.h"
97#include "llvm/Support/LEB128.h"
98#include "llvm/Support/MemoryBuffer.h"
99#include "llvm/Support/OnDiskHashTable.h"
100#include "llvm/Support/Path.h"
101#include "llvm/Support/SHA1.h"
102#include "llvm/Support/TimeProfiler.h"
103#include "llvm/Support/VersionTuple.h"
104#include "llvm/Support/raw_ostream.h"
119using namespace clang;
122template <
typename T,
typename Allocator>
123static StringRef
bytes(
const std::vector<T, Allocator> &
v) {
124 if (
v.empty())
return StringRef();
125 return StringRef(
reinterpret_cast<const char*
>(&
v[0]),
126 sizeof(T) *
v.size());
131 return StringRef(
reinterpret_cast<const char*
>(
v.data()),
132 sizeof(T) *
v.size());
135static std::string
bytes(
const std::vector<bool> &
V) {
137 Str.reserve(
V.size() / 8);
138 for (
unsigned I = 0, E =
V.size(); I < E;) {
140 for (
unsigned Bit = 0; Bit < 8 && I < E; ++Bit, ++I)
153#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
154 case Type::CLASS_ID: return TYPE_##CODE_ID;
155#include "clang/Serialization/TypeBitCodes.def"
157 llvm_unreachable(
"shouldn't be serializing a builtin type this way");
159 llvm_unreachable(
"bad type kind");
164std::set<const FileEntry *> GetAffectingModuleMaps(
const Preprocessor &PP,
176 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
189 ModulesToProcess.push_back(KH.getModule());
196 std::set<const FileEntry *> ModuleMaps{};
198 if (!ModuleMaps.insert(F).second)
212 std::set<const Module *> ProcessedModules;
213 auto CollectIncludingMapsFromAncestors = [&](
const Module *M) {
215 if (!ProcessedModules.insert(Mod).second)
220 CollectIncludingModuleMaps(*ModuleMapFile);
225 CollectIncludingModuleMaps(*ModuleMapFile);
229 for (
const Module *CurrentModule : ModulesToProcess) {
230 CollectIncludingMapsFromAncestors(CurrentModule);
232 CollectIncludingMapsFromAncestors(ImportedModule);
234 CollectIncludingMapsFromAncestors(UndeclaredModule);
247 : Writer(Writer), BasicWriter(Writer,
Record) {}
272 Record.AddSourceLocation(Loc, Seq);
280#define ABSTRACT_TYPELOC(CLASS, PARENT)
281#define TYPELOC(CLASS, PARENT) \
282 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
283#include "clang/AST/TypeLocNodes.def"
347 VisitArrayTypeLoc(TL);
351 VisitArrayTypeLoc(TL);
355 VisitArrayTypeLoc(TL);
358void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
360 VisitArrayTypeLoc(TL);
363void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
367 addSourceLocation(
range.getBegin());
368 addSourceLocation(
range.getEnd());
372void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
381void TypeLocWriter::VisitDependentVectorTypeLoc(
393 addSourceLocation(
range.getBegin());
394 addSourceLocation(
range.getEnd());
399void TypeLocWriter::VisitDependentSizedMatrixTypeLoc(
403 addSourceLocation(
range.getBegin());
404 addSourceLocation(
range.getEnd());
415 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i)
420 VisitFunctionTypeLoc(TL);
424 VisitFunctionTypeLoc(TL);
489void TypeLocWriter::VisitAutoTypeLoc(
AutoTypeLoc TL) {
494 Record.AddConceptReference(CR);
500void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
509void TypeLocWriter::VisitEnumTypeLoc(
EnumTypeLoc TL) {
525void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
530void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
535void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
541 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
570void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
578 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I)
614void TypeLocWriter::VisitPipeTypeLoc(
PipeTypeLoc TL) {
621void TypeLocWriter::VisitDependentBitIntTypeLoc(
626void ASTWriter::WriteTypeAbbrevs() {
627 using namespace llvm;
629 std::shared_ptr<BitCodeAbbrev> Abv;
632 Abv = std::make_shared<BitCodeAbbrev>();
634 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
635 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3));
636 TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv));
644 llvm::BitstreamWriter &Stream,
648 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID,
Record);
651 if (!Name || Name[0] == 0)
655 Record.push_back(*Name++);
656 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
Record);
660 llvm::BitstreamWriter &Stream,
665 Record.push_back(*Name++);
666 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME,
Record);
671#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
803void ASTWriter::WriteBlockInfoBlock() {
805 Stream.EnterBlockInfoBlock();
807#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
808#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
811 BLOCK(CONTROL_BLOCK);
821 BLOCK(OPTIONS_BLOCK);
828 BLOCK(INPUT_FILES_BLOCK);
889 BLOCK(SOURCE_MANAGER_BLOCK);
897 BLOCK(PREPROCESSOR_BLOCK);
905 BLOCK(SUBMODULE_BLOCK);
927 BLOCK(COMMENTS_BLOCK);
931 BLOCK(DECLTYPES_BLOCK);
935 RECORD(TYPE_BLOCK_POINTER);
936 RECORD(TYPE_LVALUE_REFERENCE);
937 RECORD(TYPE_RVALUE_REFERENCE);
938 RECORD(TYPE_MEMBER_POINTER);
939 RECORD(TYPE_CONSTANT_ARRAY);
940 RECORD(TYPE_INCOMPLETE_ARRAY);
941 RECORD(TYPE_VARIABLE_ARRAY);
944 RECORD(TYPE_FUNCTION_NO_PROTO);
945 RECORD(TYPE_FUNCTION_PROTO);
951 RECORD(TYPE_OBJC_INTERFACE);
952 RECORD(TYPE_OBJC_OBJECT_POINTER);
955 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
956 RECORD(TYPE_UNRESOLVED_USING);
957 RECORD(TYPE_INJECTED_CLASS_NAME);
959 RECORD(TYPE_TEMPLATE_TYPE_PARM);
960 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
961 RECORD(TYPE_DEPENDENT_NAME);
962 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
963 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
965 RECORD(TYPE_MACRO_QUALIFIED);
966 RECORD(TYPE_PACK_EXPANSION);
968 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
970 RECORD(TYPE_UNARY_TRANSFORM);
974 RECORD(TYPE_OBJC_TYPE_PARAM);
1051 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
1057 BLOCK(EXTENSION_BLOCK);
1060 BLOCK(UNHASHED_CONTROL_BLOCK);
1079 return Changed | llvm::sys::path::remove_dots(Path);
1094 assert(
Filename &&
"No file name to adjust?");
1096 if (BaseDir.empty())
1101 for (;
Filename[Pos] && Pos < BaseDir.size(); ++Pos)
1111 if (!llvm::sys::path::is_separator(
Filename[Pos])) {
1112 if (!llvm::sys::path::is_separator(BaseDir.back()))
1129std::pair<ASTFileSignature, ASTFileSignature>
1130ASTWriter::createSignature()
const {
1131 StringRef AllBytes(Buffer.data(), Buffer.size());
1134 Hasher.update(AllBytes.slice(ASTBlockRange.first, ASTBlockRange.second));
1139 Hasher.update(AllBytes.slice(0, UnhashedControlBlockRange.first));
1142 AllBytes.slice(UnhashedControlBlockRange.second, ASTBlockRange.first));
1144 Hasher.update(AllBytes.slice(ASTBlockRange.second, StringRef::npos));
1147 return std::make_pair(ASTBlockHash, Signature);
1151 if (!WritingModule ||
1158 for (uint8_t Byte : S) {
1159 Stream.BackpatchByte(BitNo, Byte);
1166 std::tie(ASTBlockHash, Signature) = createSignature();
1168 BackpatchSignatureAt(ASTBlockHash, ASTBlockHashOffset);
1169 BackpatchSignatureAt(Signature, SignatureOffset);
1174void ASTWriter::writeUnhashedControlBlock(
Preprocessor &PP,
1176 using namespace llvm;
1179 Stream.FlushToWord();
1180 UnhashedControlBlockRange.first = Stream.GetCurrentBitNo() >> 3;
1187 if (WritingModule &&
1199 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1201 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1202 unsigned ASTBlockHashAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1204 Abbrev = std::make_shared<BitCodeAbbrev>();
1205 Abbrev->Add(BitCodeAbbrevOp(
SIGNATURE));
1206 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1207 unsigned SignatureAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1210 Stream.EmitRecordWithBlob(ASTBlockHashAbbrev,
Record, Blob);
1211 ASTBlockHashOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1215 Stream.EmitRecordWithBlob(SignatureAbbrev,
Record, Blob);
1216 SignatureOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1225 if (!HSOpts.ModulesSkipDiagnosticOptions) {
1226#define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1227#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1228 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1229#include "clang/Basic/DiagnosticOptions.def"
1231 for (
unsigned I = 0, N = DiagOpts.
Warnings.size(); I != N; ++I)
1234 for (
unsigned I = 0, N = DiagOpts.
Remarks.size(); I != N; ++I)
1243 if (!HSOpts.ModulesSkipHeaderSearchPaths) {
1245 Record.push_back(HSOpts.UserEntries.size());
1246 for (
unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
1249 Record.push_back(
static_cast<unsigned>(Entry.
Group));
1255 Record.push_back(HSOpts.SystemHeaderPrefixes.size());
1256 for (
unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
1258 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
1262 Record.push_back(HSOpts.VFSOverlayFiles.size());
1263 for (StringRef VFSOverlayFile : HSOpts.VFSOverlayFiles)
1269 if (!HSOpts.ModulesSkipPragmaDiagnosticMappings)
1270 WritePragmaDiagnosticMappings(Diags, WritingModule);
1275 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1277 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1278 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1279 unsigned HSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1281 HSEntryUsage.size()};
1282 Stream.EmitRecordWithBlob(HSUsageAbbrevCode,
Record,
bytes(HSEntryUsage));
1288 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1289 Abbrev->Add(BitCodeAbbrevOp(
VFS_USAGE));
1290 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1291 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1292 unsigned VFSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1294 Stream.EmitRecordWithBlob(VFSUsageAbbrevCode,
Record,
bytes(VFSUsage));
1299 UnhashedControlBlockRange.second = Stream.GetCurrentBitNo() >> 3;
1304 StringRef isysroot) {
1305 using namespace llvm;
1311 auto MetadataAbbrev = std::make_shared<BitCodeAbbrev>();
1312 MetadataAbbrev->Add(BitCodeAbbrevOp(
METADATA));
1313 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1314 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1315 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1316 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1317 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1319 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1320 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1321 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1322 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1323 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));
1324 assert((!WritingModule || isysroot.empty()) &&
1325 "writing module as a relocatable PCH?");
1330 CLANG_VERSION_MAJOR,
1331 CLANG_VERSION_MINOR,
1335 ASTHasCompilerErrors};
1336 Stream.EmitRecordWithBlob(MetadataAbbrevCode,
Record,
1340 if (WritingModule) {
1342 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1344 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1345 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1347 Stream.EmitRecordWithBlob(AbbrevCode,
Record, WritingModule->
Name);
1350 if (WritingModule && WritingModule->
Directory) {
1357 BaseDir.assign(CWD->getName());
1372 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1374 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1375 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1378 Stream.EmitRecordWithBlob(AbbrevCode,
Record, BaseDir);
1382 BaseDirectory.assign(BaseDir.begin(), BaseDir.end());
1383 }
else if (!isysroot.empty()) {
1385 BaseDirectory = std::string(isysroot);
1394 ? Map.getModuleMapFileForUniquing(WritingModule)
1395 ->getNameAsRequested()
1400 if (
auto *AdditionalModMaps =
1401 Map.getAdditionalModuleMapFiles(WritingModule)) {
1402 Record.push_back(AdditionalModMaps->size());
1404 AdditionalModMaps->end());
1424 if (!M.isDirectlyImported())
1427 Record.push_back((
unsigned)M.Kind);
1428 Record.push_back(M.StandardCXXModule);
1433 if (!M.StandardCXXModule) {
1436 Record.push_back(M.Signature ? 0 : M.File.getSize());
1438 llvm::append_range(
Record, M.Signature);
1443 if (!M.StandardCXXModule)
1455#define LANGOPT(Name, Bits, Default, Description) \
1456 Record.push_back(LangOpts.Name);
1457#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1458 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1459#include "clang/Basic/LangOptions.def"
1460#define SANITIZER(NAME, ID) \
1461 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID));
1462#include "clang/Basic/Sanitizers.def"
1502 for (
unsigned I = 0, N = TargetOpts.
Features.size(); I != N; ++I) {
1543 bool WriteMacros = !SkipMacros;
1544 Record.push_back(WriteMacros);
1548 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
1556 for (
unsigned I = 0, N = PPOpts.
Includes.size(); I != N; ++I)
1561 for (
unsigned I = 0, N = PPOpts.
MacroIncludes.size(); I != N; ++I)
1576 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID())) {
1577 auto FileAbbrev = std::make_shared<BitCodeAbbrev>();
1579 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1580 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1581 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));
1593 WriteInputFiles(Context.SourceMgr,
1601struct InputFileEntry {
1605 bool BufferOverridden;
1608 uint32_t ContentHash[2];
1617 using namespace llvm;
1622 auto IFAbbrev = std::make_shared<BitCodeAbbrev>();
1624 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1625 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12));
1626 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
1627 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1628 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1629 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1630 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1631 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
1632 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1633 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));
1636 auto IFHAbbrev = std::make_shared<BitCodeAbbrev>();
1638 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1639 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1640 unsigned IFHAbbrevCode = Stream.EmitAbbrev(std::move(IFHAbbrev));
1642 uint64_t InputFilesOffsetBase = Stream.GetCurrentBitNo();
1645 std::vector<InputFileEntry> UserFiles;
1646 std::vector<InputFileEntry> SystemFiles;
1650 assert(&SourceMgr.
getSLocEntry(FileID::get(I)) == SLoc);
1657 if (!
Cache->OrigEntry)
1661 if (!IsSLocAffecting[I])
1664 InputFileEntry Entry(*
Cache->OrigEntry);
1665 Entry.IsSystemFile =
isSystem(
File.getFileCharacteristic());
1666 Entry.IsTransient =
Cache->IsTransient;
1667 Entry.BufferOverridden =
Cache->BufferOverridden;
1668 Entry.IsTopLevel =
File.getIncludeLoc().isInvalid();
1671 auto ContentHash = hash_code(-1);
1675 auto MemBuff =
Cache->getBufferIfLoaded();
1677 ContentHash =
hash_value(MemBuff->getBuffer());
1680 << Entry.File.getName();
1682 auto CH = llvm::APInt(64, ContentHash);
1683 Entry.ContentHash[0] =
1684 static_cast<uint32_t
>(CH.getLoBits(32).getZExtValue());
1685 Entry.ContentHash[1] =
1686 static_cast<uint32_t
>(CH.getHiBits(32).getZExtValue());
1688 if (Entry.IsSystemFile)
1689 SystemFiles.push_back(Entry);
1691 UserFiles.push_back(Entry);
1695 auto SortedFiles = llvm::concat<InputFileEntry>(std::move(UserFiles),
1696 std::move(SystemFiles));
1698 unsigned UserFilesNum = 0;
1700 std::vector<uint64_t> InputFileOffsets;
1701 for (
const auto &Entry : SortedFiles) {
1702 uint32_t &InputFileID = InputFileIDs[Entry.File];
1703 if (InputFileID != 0)
1707 InputFileOffsets.push_back(Stream.GetCurrentBitNo() - InputFilesOffsetBase);
1709 InputFileID = InputFileOffsets.size();
1711 if (!Entry.IsSystemFile)
1723 if (Name == NameAsRequested)
1726 RecordData::value_type
Record[] = {
1728 InputFileOffsets.size(),
1731 Entry.BufferOverridden,
1735 NameAsRequested.size()};
1737 Stream.EmitRecordWithBlob(IFAbbrevCode,
Record,
1738 (NameAsRequested + Name).str());
1744 Entry.ContentHash[1]};
1745 Stream.EmitRecordWithAbbrev(IFHAbbrevCode,
Record);
1752 auto OffsetsAbbrev = std::make_shared<BitCodeAbbrev>();
1754 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1755 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1757 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1758 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));
1762 InputFileOffsets.size(), UserFilesNum};
1763 Stream.EmitRecordWithBlob(OffsetsAbbrevCode,
Record,
bytes(InputFileOffsets));
1773 using namespace llvm;
1775 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1777 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1778 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1779 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1780 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1782 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1783 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1784 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24));
1785 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1786 return Stream.EmitAbbrev(std::move(Abbrev));
1792 using namespace llvm;
1794 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1796 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1797 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1798 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1799 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1800 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1801 return Stream.EmitAbbrev(std::move(Abbrev));
1808 using namespace llvm;
1810 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1814 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1815 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1816 return Stream.EmitAbbrev(std::move(Abbrev));
1822 using namespace llvm;
1824 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1826 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1827 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1828 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1829 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1830 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1831 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1832 return Stream.EmitAbbrev(std::move(Abbrev));
1837static std::pair<unsigned, unsigned>
1839 llvm::encodeULEB128(KeyLen, Out);
1840 llvm::encodeULEB128(DataLen, Out);
1841 return std::make_pair(KeyLen, DataLen);
1847 class HeaderFileInfoTrait {
1852 llvm::StringMap<unsigned> FrameworkNameOffset;
1855 HeaderFileInfoTrait(
ASTWriter &Writer) : Writer(Writer) {}
1862 using key_type_ref =
const key_type &;
1864 using UnresolvedModule =
1865 llvm::PointerIntPair<Module *, 2, ModuleMap::ModuleHeaderRole>;
1869 bool AlreadyIncluded;
1873 using data_type_ref =
const data_type &;
1882 return llvm::hash_combine(key.Size, key.ModTime);
1885 std::pair<unsigned, unsigned>
1886 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref
Data) {
1887 unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
1888 unsigned DataLen = 1 + 4 + 4;
1889 for (
auto ModInfo :
Data.KnownHeaders)
1892 if (
Data.Unresolved.getPointer())
1897 void EmitKey(raw_ostream& Out, key_type_ref key,
unsigned KeyLen) {
1898 using namespace llvm::support;
1900 endian::Writer
LE(Out, llvm::endianness::little);
1905 Out.write(key.Filename.data(), KeyLen);
1908 void EmitData(raw_ostream &Out, key_type_ref key,
1909 data_type_ref
Data,
unsigned DataLen) {
1910 using namespace llvm::support;
1912 endian::Writer
LE(Out, llvm::endianness::little);
1913 uint64_t Start = Out.tell(); (void)Start;
1915 unsigned char Flags = (
Data.AlreadyIncluded << 6)
1916 | (
Data.HFI.isImport << 5)
1918 Data.HFI.isPragmaOnce << 4)
1919 | (
Data.HFI.DirInfo << 1)
1920 |
Data.HFI.IndexHeaderMapHeader;
1921 LE.write<uint8_t>(Flags);
1923 if (!
Data.HFI.ControllingMacro)
1924 LE.write<uint32_t>(
Data.HFI.ControllingMacroID);
1928 unsigned Offset = 0;
1929 if (!
Data.HFI.Framework.empty()) {
1931 llvm::StringMap<unsigned>::iterator Pos
1932 = FrameworkNameOffset.find(
Data.HFI.Framework);
1933 if (Pos == FrameworkNameOffset.end()) {
1934 Offset = FrameworkStringData.size() + 1;
1935 FrameworkStringData.append(
Data.HFI.Framework);
1936 FrameworkStringData.push_back(0);
1938 FrameworkNameOffset[
Data.HFI.Framework] = Offset;
1940 Offset = Pos->second;
1942 LE.write<uint32_t>(Offset);
1946 uint32_t
Value = (ModID << 3) | (
unsigned)Role;
1947 assert((
Value >> 3) == ModID &&
"overflow in header module info");
1952 for (
auto ModInfo :
Data.KnownHeaders)
1953 EmitModule(ModInfo.getModule(), ModInfo.getRole());
1954 if (
Data.Unresolved.getPointer())
1955 EmitModule(
Data.Unresolved.getPointer(),
Data.Unresolved.getInt());
1957 assert(Out.tell() - Start == DataLen &&
"Wrong data length");
1960 const char *strings_begin()
const {
return FrameworkStringData.begin(); }
1961 const char *strings_end()
const {
return FrameworkStringData.end(); }
1969void ASTWriter::WriteHeaderSearch(
const HeaderSearch &HS) {
1970 HeaderFileInfoTrait GeneratorTrait(*
this);
1971 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait>
Generator;
1973 unsigned NumHeaderSearchEntries = 0;
1980 if (WritingModule) {
1982 while (!Worklist.empty()) {
1983 Module *M = Worklist.pop_back_val();
2000 if (!
U.Size || (!
U.ModTime && IncludeTimestamps)) {
2001 PP->
Diag(
U.FileNameLoc, diag::err_module_no_size_mtime_for_header)
2009 llvm::sys::path::append(
Filename,
U.FileName);
2012 StringRef FilenameDup = strdup(
Filename.c_str());
2013 SavedStrings.push_back(FilenameDup.data());
2015 HeaderFileInfoTrait::key_type Key = {
2016 FilenameDup, *
U.Size, IncludeTimestamps ? *
U.ModTime : 0};
2017 HeaderFileInfoTrait::data_type
Data = {
2022 ++NumHeaderSearchEntries;
2025 Worklist.append(SubmodulesRange.begin(), SubmodulesRange.end());
2035 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
2057 Filename = StringRef(strdup(FilenameTmp.c_str()));
2058 SavedStrings.push_back(
Filename.data());
2063 HeaderFileInfoTrait::key_type Key = {
2066 HeaderFileInfoTrait::data_type
Data = {
2070 ++NumHeaderSearchEntries;
2075 uint32_t BucketOffset;
2077 using namespace llvm::support;
2079 llvm::raw_svector_ostream Out(TableData);
2081 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
2082 BucketOffset =
Generator.Emit(Out, GeneratorTrait);
2086 using namespace llvm;
2088 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2090 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2091 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2092 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2093 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2094 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2098 NumHeaderSearchEntries, TableData.size()};
2099 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
2100 Stream.EmitRecordWithBlob(TableAbbrev,
Record, TableData);
2103 for (
unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
2104 free(
const_cast<char *
>(SavedStrings[I]));
2107static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
2108 unsigned SLocBufferBlobCompressedAbbrv,
2109 unsigned SLocBufferBlobAbbrv) {
2110 using RecordDataType = ASTWriter::RecordData::value_type;
2115 if (llvm::compression::zstd::isAvailable()) {
2116 llvm::compression::zstd::compress(
2117 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer, 9);
2119 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2120 llvm::toStringRef(CompressedBuffer));
2123 if (llvm::compression::zlib::isAvailable()) {
2124 llvm::compression::zlib::compress(
2125 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer);
2127 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2128 llvm::toStringRef(CompressedBuffer));
2133 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv,
Record, Blob);
2144void ASTWriter::WriteSourceManagerBlock(
SourceManager &SourceMgr,
2150 const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo();
2156 unsigned SLocBufferBlobCompressedAbbrv =
2162 std::vector<uint32_t> SLocEntryOffsets;
2163 uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
2169 FileID FID = FileID::get(I);
2173 uint64_t Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;
2174 assert((Offset >> 32) == 0 &&
"SLocEntry offset too large");
2180 if (
Cache->OrigEntry) {
2193 if (!IsSLocAffecting[I])
2195 SLocEntryOffsets.push_back(Offset);
2199 Record.push_back(
File.getFileCharacteristic());
2202 bool EmitBlob =
false;
2205 "Writing to AST an overridden file is not supported");
2208 assert(InputFileIDs[*Content->
OrigEntry] != 0 &&
"Missed file entry");
2211 Record.push_back(getAdjustedNumCreatedFIDs(FID));
2213 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
2214 if (FDI != FileDeclIDs.end()) {
2215 Record.push_back(FDI->second->FirstDeclIndex);
2216 Record.push_back(FDI->second->DeclIDs.size());
2222 Stream.EmitRecordWithAbbrev(SLocFileAbbrv,
Record);
2233 std::optional<llvm::MemoryBufferRef> Buffer =
2235 StringRef Name = Buffer ? Buffer->getBufferIdentifier() :
"";
2236 Stream.EmitRecordWithBlob(SLocBufferAbbrv,
Record,
2237 StringRef(Name.data(), Name.size() + 1));
2244 std::optional<llvm::MemoryBufferRef> Buffer =
2247 Buffer = llvm::MemoryBufferRef(
"<<<INVALID BUFFER>>>",
"");
2248 StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
2249 emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
2250 SLocBufferBlobAbbrv);
2255 SLocEntryOffsets.push_back(Offset);
2271 Record.push_back(getAdjustedOffset(NextOffset - SLoc->
getOffset()) - 1);
2272 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv,
Record);
2278 if (SLocEntryOffsets.empty())
2283 using namespace llvm;
2285 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2287 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2288 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2289 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2290 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2291 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2293 RecordData::value_type
Record[] = {
2296 SLocEntryOffsetsBase - SourceManagerBlockOffset};
2297 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev,
Record,
2298 bytes(SLocEntryOffsets));
2309 llvm::DenseMap<int, int> FilenameMap;
2310 FilenameMap[-1] = -1;
2311 for (
const auto &L : LineTable) {
2314 for (
auto &LE : L.second) {
2315 if (FilenameMap.insert(std::make_pair(
LE.FilenameID,
2316 FilenameMap.size() - 1)).second)
2323 for (
const auto &L : LineTable) {
2331 Record.push_back(L.second.size());
2332 for (
const auto &LE : L.second) {
2335 Record.push_back(FilenameMap[
LE.FilenameID]);
2336 Record.push_back((
unsigned)
LE.FileKind);
2337 Record.push_back(
LE.IncludeOffset);
2352 if (MI->isBuiltinMacro())
2368void ASTWriter::WritePreprocessor(
const Preprocessor &PP,
bool IsModule) {
2369 uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo();
2373 WritePreprocessorDetail(*PPRec, MacroOffsetsBase);
2388 if (AssumeNonNullLoc.
isValid()) {
2402 Record.push_back(SkipInfo->FoundNonSkipPortion);
2403 Record.push_back(SkipInfo->FoundElse);
2410 Record.push_back(Cond.WasSkipping);
2411 Record.push_back(Cond.FoundNonSkip);
2412 Record.push_back(Cond.FoundElse);
2436 if (
Id.second->hadMacroDefinition() &&
2437 (!
Id.second->isFromAST() ||
2438 Id.second->hasChangedSinceDeserialization()))
2439 MacroIdentifiers.push_back(
Id.second);
2442 llvm::sort(MacroIdentifiers, llvm::deref<std::less<>>());
2448 uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2449 assert((StartOffset >> 32) == 0 &&
"Macro identifiers offset too large");
2452 bool EmittedModuleMacros =
false;
2469 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2471 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2472 Record.push_back(VisMD->isPublic());
2474 ModuleMacroRecord.push_back(getSubmoduleID(WritingModule));
2477 ModuleMacroRecord.clear();
2478 EmittedModuleMacros =
true;
2488 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2490 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2491 Record.push_back(VisMD->isPublic());
2498 llvm::DenseMap<ModuleMacro *, unsigned> Visits;
2499 while (!Worklist.empty()) {
2500 auto *
Macro = Worklist.pop_back_val();
2503 ModuleMacroRecord.push_back(getSubmoduleID(
Macro->getOwningModule()));
2505 for (
auto *M :
Macro->overrides())
2506 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));
2509 ModuleMacroRecord.clear();
2512 for (
auto *M :
Macro->overrides())
2513 if (++Visits[M] == M->getNumOverridingMacros())
2514 Worklist.push_back(M);
2516 EmittedModuleMacros =
true;
2519 if (
Record.empty() && !EmittedModuleMacros)
2522 IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2533 std::vector<uint32_t> MacroOffsets;
2535 for (
unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2540 if (ID < FirstMacroID) {
2541 assert(0 &&
"Loaded MacroInfo entered MacroInfosToEmit ?");
2546 unsigned Index =
ID - FirstMacroID;
2547 if (Index >= MacroOffsets.size())
2548 MacroOffsets.resize(Index + 1);
2550 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2551 assert((Offset >> 32) == 0 &&
"Macro offset too large");
2552 MacroOffsets[Index] = Offset;
2579 Stream.EmitRecord(Code,
Record);
2583 for (
unsigned TokNo = 0, e = MI->
getNumTokens(); TokNo != e; ++TokNo) {
2598 using namespace llvm;
2600 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2602 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2603 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2604 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2605 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2607 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2611 MacroOffsetsBase - ASTBlockStartOffset};
2612 Stream.EmitRecordWithBlob(MacroOffsetAbbrev,
Record,
bytes(MacroOffsets));
2617 uint64_t MacroOffsetsBase) {
2627 unsigned NumPreprocessingRecords = 0;
2628 using namespace llvm;
2631 unsigned InclusionAbbrev = 0;
2633 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2635 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2636 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2637 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
2638 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2639 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2640 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2643 unsigned FirstPreprocessorEntityID
2644 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2646 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
2651 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
2654 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2655 assert((Offset >> 32) == 0 &&
"Preprocessed entity offset too large");
2656 PreprocessedEntityOffsets.push_back(
2657 PPEntityOffset(getAdjustedRange((*E)->getSourceRange()), Offset));
2659 if (
auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) {
2661 MacroDefinitions[MD] = NextPreprocessorEntityID;
2668 if (
auto *ME = dyn_cast<MacroExpansion>(*E)) {
2669 Record.push_back(ME->isBuiltinMacro());
2670 if (ME->isBuiltinMacro())
2673 Record.push_back(MacroDefinitions[ME->getDefinition()]);
2678 if (
auto *ID = dyn_cast<InclusionDirective>(*E)) {
2680 Record.push_back(
ID->getFileName().size());
2681 Record.push_back(
ID->wasInQuotes());
2682 Record.push_back(
static_cast<unsigned>(
ID->getKind()));
2683 Record.push_back(
ID->importedModule());
2685 Buffer +=
ID->getFileName();
2689 Buffer +=
ID->getFile()->getName();
2690 Stream.EmitRecordWithBlob(InclusionAbbrev,
Record, Buffer);
2694 llvm_unreachable(
"Unhandled PreprocessedEntity in ASTWriter");
2699 if (NumPreprocessingRecords > 0) {
2700 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2703 using namespace llvm;
2705 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2707 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2708 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2709 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2712 FirstPreprocessorEntityID -
2714 Stream.EmitRecordWithBlob(PPEOffsetAbbrev,
Record,
2715 bytes(PreprocessedEntityOffsets));
2720 if (SkippedRanges.size() > 0) {
2721 std::vector<PPSkippedRange> SerializedSkippedRanges;
2722 SerializedSkippedRanges.reserve(SkippedRanges.size());
2723 for (
auto const& Range : SkippedRanges)
2724 SerializedSkippedRanges.emplace_back(Range);
2726 using namespace llvm;
2727 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2729 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2730 unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2734 Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev,
Record,
2735 bytes(SerializedSkippedRanges));
2743 auto Known = SubmoduleIDs.find(Mod);
2744 if (Known != SubmoduleIDs.end())
2745 return Known->second;
2748 if (Top != WritingModule &&
2750 !Top->fullModuleNameIs(StringRef(
getLangOpts().CurrentModule))))
2753 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2756unsigned ASTWriter::getSubmoduleID(
Module *Mod) {
2769 unsigned ChildModules = 0;
2773 return ChildModules + 1;
2776void ASTWriter::WriteSubmodules(
Module *WritingModule) {
2781 using namespace llvm;
2783 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2785 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2786 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2787 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));
2788 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
2789 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2790 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2791 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2792 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2793 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2794 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2795 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2796 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2797 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2798 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2799 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2800 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2802 Abbrev = std::make_shared<BitCodeAbbrev>();
2804 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2805 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2807 Abbrev = std::make_shared<BitCodeAbbrev>();
2809 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2810 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2812 Abbrev = std::make_shared<BitCodeAbbrev>();
2814 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2815 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2817 Abbrev = std::make_shared<BitCodeAbbrev>();
2819 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2820 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2822 Abbrev = std::make_shared<BitCodeAbbrev>();
2824 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2825 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2826 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2828 Abbrev = std::make_shared<BitCodeAbbrev>();
2830 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2831 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2833 Abbrev = std::make_shared<BitCodeAbbrev>();
2835 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2836 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2838 Abbrev = std::make_shared<BitCodeAbbrev>();
2840 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2841 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2843 Abbrev = std::make_shared<BitCodeAbbrev>();
2845 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2846 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2848 Abbrev = std::make_shared<BitCodeAbbrev>();
2850 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2851 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2852 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2854 Abbrev = std::make_shared<BitCodeAbbrev>();
2856 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2857 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2859 Abbrev = std::make_shared<BitCodeAbbrev>();
2861 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2862 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2863 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2865 Abbrev = std::make_shared<BitCodeAbbrev>();
2867 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2868 unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2871 RecordData::value_type
Record[] = {
2877 std::queue<Module *> Q;
2878 Q.push(WritingModule);
2879 while (!Q.empty()) {
2882 unsigned ID = getSubmoduleID(Mod);
2886 assert(SubmoduleIDs[Mod->
Parent] &&
"Submodule parent not written?");
2887 ParentID = SubmoduleIDs[Mod->
Parent];
2898 (RecordData::value_type)Mod->
Kind,
2910 Stream.EmitRecordWithBlob(DefinitionAbbrev,
Record, Mod->
Name);
2916 Stream.EmitRecordWithBlob(RequiresAbbrev,
Record, R.first);
2920 if (std::optional<Module::Header> UmbrellaHeader =
2923 Stream.EmitRecordWithBlob(UmbrellaAbbrev,
Record,
2924 UmbrellaHeader->NameAsWritten);
2925 }
else if (std::optional<Module::DirectoryName> UmbrellaDir =
2928 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev,
Record,
2929 UmbrellaDir->NameAsWritten);
2934 unsigned RecordKind;
2945 for (
auto &HL : HeaderLists) {
2946 RecordData::value_type
Record[] = {HL.RecordKind};
2947 for (
auto &H : Mod->
Headers[HL.HeaderKind])
2948 Stream.EmitRecordWithBlob(HL.Abbrev,
Record, H.NameAsWritten);
2957 Stream.EmitRecordWithBlob(TopHeaderAbbrev,
Record, HeaderName);
2965 Record.push_back(getSubmoduleID(I));
2973 Record.push_back(getSubmoduleID(I));
2980 for (
const auto &E : Mod->
Exports) {
2983 Record.push_back(getSubmoduleID(E.getPointer()));
2984 Record.push_back(E.getInt());
2999 Stream.EmitRecordWithBlob(LinkLibraryAbbrev,
Record, LL.Library);
3007 getSubmoduleID(
C.Other)};
3008 Stream.EmitRecordWithBlob(ConflictAbbrev,
Record,
C.Message);
3014 Stream.EmitRecordWithBlob(ConfigMacroAbbrev,
Record, CM);
3037 assert((NextSubmoduleID - FirstSubmoduleID ==
3039 "Wrong # of submodules; found a reference to a non-local, "
3040 "non-imported submodule?");
3045 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
3047 unsigned CurrID = 0;
3050 auto EncodeDiagStateFlags =
3051 [](
const DiagnosticsEngine::DiagState *DS) ->
unsigned {
3054 {(
unsigned)DS->IgnoreAllWarnings, (
unsigned)DS->EnableAllWarnings,
3055 (
unsigned)DS->WarningsAsErrors, (
unsigned)DS->ErrorsAsFatal,
3056 (
unsigned)DS->SuppressSystemWarnings})
3061 unsigned Flags = EncodeDiagStateFlags(
Diag.DiagStatesByLoc.FirstDiagState);
3064 auto AddDiagState = [&](
const DiagnosticsEngine::DiagState *State,
3065 bool IncludeNonPragmaStates) {
3068 assert(Flags == EncodeDiagStateFlags(State) &&
3069 "diag state flags vary in single AST file");
3073 assert(!IncludeNonPragmaStates ||
3074 State ==
Diag.DiagStatesByLoc.FirstDiagState);
3076 unsigned &DiagStateID = DiagStateIDMap[State];
3077 Record.push_back(DiagStateID);
3079 if (DiagStateID == 0) {
3080 DiagStateID = ++CurrID;
3084 auto SizeIdx =
Record.size();
3086 for (
const auto &I : *State) {
3088 if (!I.second.isPragma() && !IncludeNonPragmaStates)
3092 if (!I.second.isPragma() &&
3095 Mappings.push_back(I);
3099 llvm::sort(Mappings, [](
const auto &LHS,
const auto &RHS) {
3100 return LHS.first < RHS.first;
3103 for (
const auto &I : Mappings) {
3104 Record.push_back(I.first);
3105 Record.push_back(I.second.serialize());
3112 AddDiagState(
Diag.DiagStatesByLoc.FirstDiagState, isModule);
3115 auto NumLocationsIdx =
Record.size();
3119 unsigned NumLocations = 0;
3120 for (
auto &FileIDAndFile :
Diag.DiagStatesByLoc.Files) {
3121 if (!FileIDAndFile.first.isValid() ||
3122 !FileIDAndFile.second.HasLocalTransitions)
3127 assert(!Loc.
isInvalid() &&
"start loc for valid FileID is invalid");
3130 Record.push_back(FileIDAndFile.second.StateTransitions.size());
3131 for (
auto &StatePoint : FileIDAndFile.second.StateTransitions) {
3132 Record.push_back(getAdjustedOffset(StatePoint.Offset));
3133 AddDiagState(StatePoint.State,
false);
3138 Record[NumLocationsIdx] = NumLocations;
3147 AddDiagState(
Diag.DiagStatesByLoc.CurDiagState,
false);
3157void ASTWriter::WriteType(
QualType T) {
3158 TypeIdx &IdxRef = TypeIdxs[T];
3160 IdxRef =
TypeIdx(NextTypeID++);
3163 assert(Idx.
getIndex() >= FirstTypeID &&
"Re-writing a type from a prior AST");
3166 uint64_t Offset = ASTTypeWriter(*this).write(T) - DeclTypesBlockStartOffset;
3169 unsigned Index = Idx.
getIndex() - FirstTypeID;
3170 if (TypeOffsets.size() == Index)
3171 TypeOffsets.emplace_back(Offset);
3172 else if (TypeOffsets.size() < Index) {
3173 TypeOffsets.resize(Index + 1);
3174 TypeOffsets[Index].setBitOffset(Offset);
3176 llvm_unreachable(
"Types emitted in wrong order");
3194 uint64_t Offset = Stream.GetCurrentBitNo();
3196 for (
const auto *D : DC->
decls()) {
3197 KindDeclPairs.push_back(D->getKind());
3201 ++NumLexicalDeclContexts;
3203 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev,
Record,
3204 bytes(KindDeclPairs));
3208void ASTWriter::WriteTypeDeclOffsets() {
3209 using namespace llvm;
3212 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3214 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3215 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3216 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3217 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3221 Stream.EmitRecordWithBlob(TypeOffsetAbbrev,
Record,
bytes(TypeOffsets));
3225 Abbrev = std::make_shared<BitCodeAbbrev>();
3227 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3228 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3229 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3230 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3234 Stream.EmitRecordWithBlob(DeclOffsetAbbrev,
Record,
bytes(DeclOffsets));
3238void ASTWriter::WriteFileDeclIDsMap() {
3239 using namespace llvm;
3242 SortedFileDeclIDs.reserve(FileDeclIDs.size());
3243 for (
const auto &
P : FileDeclIDs)
3244 SortedFileDeclIDs.push_back(std::make_pair(
P.first,
P.second.get()));
3245 llvm::sort(SortedFileDeclIDs, llvm::less_first());
3249 for (
auto &FileDeclEntry : SortedFileDeclIDs) {
3250 DeclIDInFileInfo &Info = *FileDeclEntry.second;
3251 Info.FirstDeclIndex = FileGroupedDeclIDs.size();
3252 llvm::stable_sort(Info.DeclIDs);
3253 for (
auto &LocDeclEntry : Info.DeclIDs)
3254 FileGroupedDeclIDs.push_back(LocDeclEntry.second);
3257 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3259 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3260 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3261 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
3263 FileGroupedDeclIDs.size()};
3264 Stream.EmitRecordWithBlob(AbbrevCode,
Record,
bytes(FileGroupedDeclIDs));
3267void ASTWriter::WriteComments() {
3269 auto _ = llvm::make_scope_exit([
this] { Stream.ExitBlock(); });
3280 for (
const auto &FO : Context->
Comments.OrderedComments) {
3281 for (
const auto &OC : FO.second) {
3300class ASTMethodPoolTrait {
3305 using key_type_ref = key_type;
3311 using data_type_ref =
const data_type &;
3316 explicit ASTMethodPoolTrait(
ASTWriter &Writer) : Writer(Writer) {}
3322 std::pair<unsigned, unsigned>
3323 EmitKeyDataLength(raw_ostream& Out,
Selector Sel,
3324 data_type_ref Methods) {
3326 unsigned DataLen = 4 + 2 + 2;
3329 if (ShouldWriteMethodListNode(Method))
3333 if (ShouldWriteMethodListNode(Method))
3338 void EmitKey(raw_ostream& Out,
Selector Sel,
unsigned) {
3339 using namespace llvm::support;
3341 endian::Writer
LE(Out, llvm::endianness::little);
3343 assert((Start >> 32) == 0 &&
"Selector key offset too large");
3346 LE.write<uint16_t>(N);
3349 for (
unsigned I = 0; I != N; ++I)
3354 void EmitData(raw_ostream& Out, key_type_ref,
3355 data_type_ref Methods,
unsigned DataLen) {
3356 using namespace llvm::support;
3358 endian::Writer
LE(Out, llvm::endianness::little);
3359 uint64_t Start = Out.tell(); (void)Start;
3360 LE.write<uint32_t>(Methods.ID);
3361 unsigned NumInstanceMethods = 0;
3364 if (ShouldWriteMethodListNode(Method))
3365 ++NumInstanceMethods;
3367 unsigned NumFactoryMethods = 0;
3370 if (ShouldWriteMethodListNode(Method))
3371 ++NumFactoryMethods;
3373 unsigned InstanceBits = Methods.Instance.getBits();
3374 assert(InstanceBits < 4);
3375 unsigned InstanceHasMoreThanOneDeclBit =
3376 Methods.Instance.hasMoreThanOneDecl();
3377 unsigned FullInstanceBits = (NumInstanceMethods << 3) |
3378 (InstanceHasMoreThanOneDeclBit << 2) |
3380 unsigned FactoryBits = Methods.Factory.getBits();
3381 assert(FactoryBits < 4);
3382 unsigned FactoryHasMoreThanOneDeclBit =
3383 Methods.Factory.hasMoreThanOneDecl();
3384 unsigned FullFactoryBits = (NumFactoryMethods << 3) |
3385 (FactoryHasMoreThanOneDeclBit << 2) |
3387 LE.write<uint16_t>(FullInstanceBits);
3388 LE.write<uint16_t>(FullFactoryBits);
3391 if (ShouldWriteMethodListNode(Method))
3392 LE.write<uint32_t>(Writer.
getDeclID(Method->getMethod()));
3395 if (ShouldWriteMethodListNode(Method))
3396 LE.write<uint32_t>(Writer.
getDeclID(Method->getMethod()));
3398 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
3403 return (
Node->getMethod() && !
Node->getMethod()->isFromASTFile());
3414void ASTWriter::WriteSelectors(
Sema &SemaRef) {
3415 using namespace llvm;
3420 unsigned NumTableEntries = 0;
3423 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait>
Generator;
3424 ASTMethodPoolTrait Trait(*
this);
3428 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
3429 for (
auto &SelectorAndID : SelectorIDs) {
3433 ASTMethodPoolTrait::data_type
Data = {
3439 Data.Instance = F->second.first;
3440 Data.Factory = F->second.second;
3444 if (Chain && ID < FirstSelectorID) {
3446 bool changed =
false;
3449 if (!M->getMethod()->isFromASTFile()) {
3457 if (!M->getMethod()->isFromASTFile()) {
3465 }
else if (
Data.Instance.getMethod() ||
Data.Factory.getMethod()) {
3474 uint32_t BucketOffset;
3476 using namespace llvm::support;
3478 ASTMethodPoolTrait Trait(*
this);
3479 llvm::raw_svector_ostream Out(MethodPool);
3481 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3482 BucketOffset =
Generator.Emit(Out, Trait);
3486 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3488 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3489 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3490 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3491 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3497 Stream.EmitRecordWithBlob(MethodPoolAbbrev,
Record, MethodPool);
3501 Abbrev = std::make_shared<BitCodeAbbrev>();
3503 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3504 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3505 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3506 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3510 RecordData::value_type
Record[] = {
3513 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev,
Record,
3514 bytes(SelectorOffsets));
3520void ASTWriter::WriteReferencedSelectorsPool(
Sema &SemaRef) {
3521 using namespace llvm;
3533 Selector Sel = SelectorAndLocation.first;
3535 Writer.AddSelectorRef(Sel);
3557 for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
3559 if (!Redecl->isFromASTFile()) {
3563 if (!Redecl->getDeclContext()->getRedeclContext()->Equals(
3566 return cast<NamedDecl>(Redecl);
3571 if (Redecl->getOwningModuleID() == 0)
3576 if (!
First->isFromASTFile())
3577 return cast<NamedDecl>(
First);
3587class ASTIdentifierTableTrait {
3601 bool IsInteresting =
3603 tok::NotableIdentifierKind::not_notable ||
3606 if (MacroOffset || II->
isPoisoned() || (!IsModule && IsInteresting) ||
3616 using key_type_ref = key_type;
3619 using data_type_ref = data_type;
3627 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule),
3628 NeedDecls(!IsModule || !Writer.getLangOpts().
CPlusPlus),
3629 InterestingIdentifierOffsets(InterestingIdentifierOffsets) {}
3631 bool needDecls()
const {
return NeedDecls; }
3634 return llvm::djbHash(II->
getName());
3646 std::pair<unsigned, unsigned>
3656 if (InterestingIdentifierOffsets &&
3658 InterestingIdentifierOffsets->push_back(Out.tell());
3661 unsigned DataLen = 4;
3669 DataLen += std::distance(IdResolver.
begin(II), IdResolver.
end()) * 4;
3681 using namespace llvm::support;
3683 endian::Writer
LE(Out, llvm::endianness::little);
3687 LE.write<uint32_t>(
ID << 1);
3691 LE.write<uint32_t>((
ID << 1) | 0x01);
3693 assert((Bits & 0xffff) == Bits &&
"ObjCOrBuiltinID too big for ASTReader.");
3694 LE.write<uint16_t>(Bits);
3696 bool HadMacroDefinition = MacroOffset != 0;
3697 Bits = (Bits << 1) |
unsigned(HadMacroDefinition);
3699 Bits = (Bits << 1) |
unsigned(II->
isPoisoned());
3702 LE.write<uint16_t>(Bits);
3704 if (HadMacroDefinition)
3705 LE.write<uint32_t>(MacroOffset);
3715 for (
NamedDecl *D : llvm::reverse(Decls))
3732 using namespace llvm;
3739 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait>
Generator;
3740 ASTIdentifierTableTrait Trait(*
this, PP, IdResolver, IsModule,
3741 IsModule ? &InterestingIdents :
nullptr);
3750 if (Trait.isInterestingNonMacroIdentifier(
ID.second))
3751 IIs.push_back(
ID.second);
3754 llvm::sort(IIs, llvm::deref<std::less<>>());
3760 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
3761 for (
auto IdentIDPair : IdentifierIDs) {
3764 assert(II &&
"NULL identifier in identifier table");
3767 if (ID >= FirstIdentID || !Chain || !II->
isFromAST()
3769 (Trait.needDecls() &&
3776 uint32_t BucketOffset;
3778 using namespace llvm::support;
3782 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3783 BucketOffset =
Generator.Emit(Out, Trait);
3787 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3789 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3790 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3791 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3799 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3801 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3802 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3803 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3804 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3807 for (
unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
3808 assert(IdentifierOffsets[I] &&
"Missing identifier offset?");
3812 IdentifierOffsets.size(),
3814 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev,
Record,
3815 bytes(IdentifierOffsets));
3819 if (!InterestingIdents.empty())
3830class ASTDeclContextNameLookupTrait {
3836 using key_type_ref = key_type;
3839 using data_type = std::pair<unsigned, unsigned>;
3840 using data_type_ref =
const data_type &;
3845 explicit ASTDeclContextNameLookupTrait(
ASTWriter &Writer) : Writer(Writer) {}
3847 template<
typename Coll>
3848 data_type getData(
const Coll &Decls) {
3849 unsigned Start = DeclIDs.size();
3854 return std::make_pair(Start, DeclIDs.size());
3858 unsigned Start = DeclIDs.size();
3859 llvm::append_range(DeclIDs, FromReader);
3860 return std::make_pair(Start, DeclIDs.size());
3863 static bool EqualKey(key_type_ref a, key_type_ref
b) {
3868 return Name.getHash();
3871 void EmitFileRef(raw_ostream &Out,
ModuleFile *F)
const {
3873 "have reference to loaded module file but no chain?");
3875 using namespace llvm::support;
3878 llvm::endianness::little);
3881 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
3883 data_type_ref Lookup) {
3884 unsigned KeyLen = 1;
3885 switch (Name.getKind()) {
3905 unsigned DataLen = 4 * (Lookup.second - Lookup.first);
3911 using namespace llvm::support;
3913 endian::Writer
LE(Out, llvm::endianness::little);
3914 LE.write<uint8_t>(Name.getKind());
3915 switch (Name.getKind()) {
3928 "Invalid operator?");
3929 LE.write<uint8_t>(Name.getOperatorKind());
3938 llvm_unreachable(
"Invalid name kind?");
3941 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
3943 using namespace llvm::support;
3945 endian::Writer
LE(Out, llvm::endianness::little);
3946 uint64_t Start = Out.tell(); (void)Start;
3947 for (
unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
3948 LE.write<uint32_t>(DeclIDs[I]);
3949 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
3957 return Result.hasExternalDecls() &&
3958 DC->hasNeedToReconcileExternalVisibleStorage();
3963 for (
auto *D :
Result.getLookupResult())
3971ASTWriter::GenerateNameLookupTable(
const DeclContext *ConstDC,
3973 assert(!ConstDC->hasLazyLocalLexicalLookups() &&
3974 !ConstDC->hasLazyExternalLexicalLookups() &&
3975 "must call buildLookups first");
3983 ASTDeclContextNameLookupTrait>
Generator;
3984 ASTDeclContextNameLookupTrait Trait(*
this);
3996 auto &Name = Lookup.first;
3997 auto &
Result = Lookup.second;
4003 if (isLookupResultExternal(
Result, DC) &&
4004 isLookupResultEntirelyExternal(
Result, DC))
4021 if (Lookup.second.getLookupResult().empty())
4024 switch (Lookup.first.getNameKind()) {
4026 Names.push_back(Lookup.first);
4030 assert(isa<CXXRecordDecl>(DC) &&
4031 "Cannot have a constructor name outside of a class!");
4032 ConstructorNameSet.insert(Name);
4036 assert(isa<CXXRecordDecl>(DC) &&
4037 "Cannot have a conversion function name outside of a class!");
4038 ConversionNameSet.insert(Name);
4046 if (
auto *D = dyn_cast<CXXRecordDecl>(DC)) {
4060 if (ConstructorNameSet.erase(ImplicitCtorName))
4061 Names.push_back(ImplicitCtorName);
4066 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty())
4067 for (
Decl *ChildD : cast<CXXRecordDecl>(DC)->decls())
4068 if (
auto *ChildND = dyn_cast<NamedDecl>(ChildD)) {
4069 auto Name = ChildND->getDeclName();
4070 switch (Name.getNameKind()) {
4075 if (ConstructorNameSet.erase(Name))
4076 Names.push_back(Name);
4080 if (ConversionNameSet.erase(Name))
4081 Names.push_back(Name);
4085 if (ConstructorNameSet.empty() && ConversionNameSet.empty())
4089 assert(ConstructorNameSet.empty() &&
"Failed to find all of the visible "
4090 "constructors by walking all the "
4091 "lexical members of the context.");
4092 assert(ConversionNameSet.empty() &&
"Failed to find all of the visible "
4093 "conversion functions by walking all "
4094 "the lexical members of the context.");
4101 for (
auto &Name : Names)
4113 for (
auto &Name : Names) {
4116 switch (Name.getNameKind()) {
4134 if (!ConstructorDecls.empty())
4135 Generator.insert(ConstructorDecls.front()->getDeclName(),
4136 Trait.getData(ConstructorDecls), Trait);
4137 if (!ConversionDecls.empty())
4138 Generator.insert(ConversionDecls.front()->getDeclName(),
4139 Trait.getData(ConversionDecls), Trait);
4144 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table :
nullptr);
4157 if (isa<NamespaceDecl>(DC) && Chain &&
4160 for (
auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;
4161 Prev = Prev->getPreviousDecl())
4162 if (!Prev->isFromASTFile())
4175 LookupResults.reserve(Map->size());
4176 for (
auto &Entry : *Map)
4177 LookupResults.push_back(
4178 std::make_pair(Entry.first, Entry.second.getLookupResult()));
4181 llvm::sort(LookupResults, llvm::less_first());
4182 for (
auto &NameAndResult : LookupResults) {
4190 assert(
Result.empty() &&
"Cannot have a constructor or conversion "
4191 "function name in a namespace!");
4196 if (!ND->isFromASTFile())
4220 uint64_t Offset = Stream.GetCurrentBitNo();
4222 if (!Map || Map->empty())
4227 GenerateNameLookupTable(DC, LookupTable);
4231 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev,
Record,
4233 ++NumVisibleDeclContexts;
4243void ASTWriter::WriteDeclContextVisibleUpdate(
const DeclContext *DC) {
4245 if (!Map || Map->empty())
4250 GenerateNameLookupTable(DC, LookupTable);
4254 if (isa<NamespaceDecl>(DC))
4259 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev,
Record, LookupTable);
4269void ASTWriter::WriteOpenCLExtensions(
Sema &SemaRef) {
4275 for (
const auto &I:Opts.OptMap) {
4277 auto V = I.getValue();
4278 Record.push_back(
V.Supported ? 1 : 0);
4279 Record.push_back(
V.Enabled ? 1 : 0);
4280 Record.push_back(
V.WithPragma ? 1 : 0);
4287void ASTWriter::WriteCUDAPragmas(
Sema &SemaRef) {
4288 if (SemaRef.ForceCUDAHostDeviceDepth > 0) {
4289 RecordData::value_type
Record[] = {SemaRef.ForceCUDAHostDeviceDepth};
4294void ASTWriter::WriteObjCCategories() {
4298 for (
unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
4300 unsigned StartIndex = Categories.size();
4305 Categories.push_back(0);
4309 Cat =
Class->known_categories_begin(),
4310 CatEnd =
Class->known_categories_end();
4311 Cat != CatEnd; ++Cat, ++Size) {
4312 assert(
getDeclID(*Cat) != 0 &&
"Bogus category");
4317 Categories[StartIndex] =
Size;
4321 CategoriesMap.push_back(CatInfo);
4326 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
4329 using namespace llvm;
4331 auto Abbrev = std::make_shared<BitCodeAbbrev>();
4333 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
4334 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4335 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
4338 Stream.EmitRecordWithBlob(AbbrevID,
Record,
4339 reinterpret_cast<char *
>(CategoriesMap.data()),
4346void ASTWriter::WriteLateParsedTemplates(
Sema &SemaRef) {
4353 for (
auto &LPTMapEntry : LPTMap) {
4361 for (
const auto &Tok : LPT.
Toks) {
4369void ASTWriter::WriteOptimizePragmaOptions(
Sema &SemaRef) {
4377void ASTWriter::WriteMSStructPragmaOptions(
Sema &SemaRef) {
4385void ASTWriter::WriteMSPointersToMembersPragmaOptions(
Sema &SemaRef) {
4393void ASTWriter::WritePackPragmaOptions(
Sema &SemaRef) {
4413void ASTWriter::WriteFloatControlPragmaOptions(
Sema &SemaRef) {
4423 for (
const auto &StackEntry : SemaRef.
FpPragmaStack.Stack) {
4424 Record.push_back(StackEntry.Value.getAsOpaqueInt());
4432void ASTWriter::WriteModuleFileExtension(
Sema &SemaRef,
4438 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
4440 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4441 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4442 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4443 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4444 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4445 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv));
4451 Record.push_back(Metadata.MajorVersion);
4452 Record.push_back(Metadata.MinorVersion);
4453 Record.push_back(Metadata.BlockName.size());
4454 Record.push_back(Metadata.UserInfo.size());
4456 Buffer += Metadata.BlockName;
4457 Buffer += Metadata.UserInfo;
4458 Stream.EmitRecordWithBlob(Abbrev,
Record, Buffer);
4476 if (!A || (isa<PreferredNameAttr>(A) &&
4477 Writer->isWritingStdCXXNamedModules()))
4478 return Record.push_back(0);
4488 Record.push_back(A->getAttributeSpellingListIndexRaw());
4491#include "clang/Serialization/AttrPCHWrite.inc"
4497 for (
const auto *A : Attrs)
4511 case tok::annot_pragma_loop_hint: {
4515 Record.push_back(Info->Toks.size());
4516 for (
const auto &T : Info->Toks)
4520 case tok::annot_pragma_pack: {
4523 Record.push_back(
static_cast<unsigned>(Info->Action));
4529 case tok::annot_pragma_openmp:
4530 case tok::annot_pragma_openmp_end:
4531 case tok::annot_pragma_unused:
4532 case tok::annot_pragma_openacc:
4533 case tok::annot_pragma_openacc_end:
4536 llvm_unreachable(
"missing serialization code for annotation token");
4547 Record.push_back(Str.size());
4552 assert(Context &&
"should have context when outputting path");
4555 StringRef PathStr(Path.data(), Path.size());
4556 if (PathStr ==
"<built-in>" || PathStr ==
"<command line>")
4563 const char *PathBegin = Path.data();
4564 const char *PathPtr =
4566 if (PathPtr != PathBegin) {
4567 Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin));
4584 Stream.EmitRecordWithBlob(Abbrev,
Record, FilePath);
4589 Record.push_back(Version.getMajor());
4590 if (std::optional<unsigned> Minor = Version.getMinor())
4591 Record.push_back(*Minor + 1);
4594 if (std::optional<unsigned> Subminor = Version.getSubminor())
4595 Record.push_back(*Subminor + 1);
4603 IdentID ID = IdentifierIDs[II];
4606 if (ID >= FirstIdentID)
4607 IdentifierOffsets[ID - FirstIdentID] = Offset;
4613 unsigned ID = SelectorIDs[Sel];
4614 assert(ID &&
"Unknown selector");
4617 if (ID < FirstSelectorID)
4619 SelectorOffsets[ID - FirstSelectorID] = Offset;
4625 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
4626 bool IncludeTimestamps,
bool BuildingImplicitModule,
4627 bool GeneratingReducedBMI)
4628 : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),
4629 IncludeTimestamps(IncludeTimestamps),
4630 BuildingImplicitModule(BuildingImplicitModule),
4631 GeneratingReducedBMI(GeneratingReducedBMI) {
4632 for (
const auto &Ext : Extensions) {
4633 if (
auto Writer = Ext->createExtensionWriter(*
this))
4634 ModuleFileExtensionWriters.push_back(std::move(Writer));
4641 assert(WritingAST &&
"can't determine lang opts when not writing AST");
4650 Module *WritingModule, StringRef isysroot,
4651 bool ShouldCacheASTInMemory) {
4652 llvm::TimeTraceScope scope(
"WriteAST", OutputFile);
4655 ASTHasCompilerErrors =
4659 Stream.Emit((
unsigned)
'C', 8);
4660 Stream.Emit((
unsigned)
'P', 8);
4661 Stream.Emit((
unsigned)
'C', 8);
4662 Stream.Emit((
unsigned)
'H', 8);
4664 WriteBlockInfoBlock();
4668 this->WritingModule = WritingModule;
4669 ASTFileSignature Signature = WriteASTCore(SemaRef, isysroot, WritingModule);
4672 this->WritingModule =
nullptr;
4673 this->BaseDirectory.clear();
4676 if (ShouldCacheASTInMemory) {
4679 llvm::MemoryBuffer::getMemBufferCopy(
4680 StringRef(Buffer.begin(), Buffer.size())));
4685template<
typename Vector>
4688 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true), E = Vec.end();
4694void ASTWriter::computeNonAffectingInputFiles() {
4698 IsSLocAffecting.resize(N,
true);
4703 auto AffectingModuleMaps = GetAffectingModuleMaps(*PP, WritingModule);
4705 unsigned FileIDAdjustment = 0;
4706 unsigned OffsetAdjustment = 0;
4708 NonAffectingFileIDAdjustments.reserve(N);
4709 NonAffectingOffsetAdjustments.reserve(N);
4711 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
4712 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
4714 for (
unsigned I = 1; I != N; ++I) {
4716 FileID FID = FileID::get(I);
4723 if (!
Cache->OrigEntry)
4727 AffectingModuleMaps.empty() ||
4728 llvm::is_contained(AffectingModuleMaps, *
Cache->OrigEntry))
4731 IsSLocAffecting[I] =
false;
4733 FileIDAdjustment += 1;
4739 if (!NonAffectingFileIDs.empty() &&
4740 NonAffectingFileIDs.back().ID == FID.ID - 1) {
4741 NonAffectingFileIDs.back() = FID;
4743 NonAffectingFileIDAdjustments.back() = FileIDAdjustment;
4744 NonAffectingOffsetAdjustments.back() = OffsetAdjustment;
4748 NonAffectingFileIDs.push_back(FID);
4751 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
4752 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
4761 for (StringRef Path :
4764 for (
unsigned I = 1; I != N; ++I) {
4765 if (IsSLocAffecting[I]) {
4771 if (!
Cache->OrigEntry)
4774 Cache->OrigEntry->getNameAsRequested());
4782 using namespace llvm;
4784 bool isModule = WritingModule !=
nullptr;
4795 computeNonAffectingInputFiles();
4797 writeUnhashedControlBlock(PP, Context);
4811 RegisterPredefDecl(Context.ObjCProtocolClassDecl,
4815 RegisterPredefDecl(Context.ObjCInstanceTypeDecl,
4819 RegisterPredefDecl(Context.BuiltinMSVaListDecl,
4824 RegisterPredefDecl(Context.MakeIntegerSeqDecl,
4826 RegisterPredefDecl(Context.CFConstantStringTypeDecl,
4828 RegisterPredefDecl(Context.CFConstantStringTagDecl,
4830 RegisterPredefDecl(Context.TypePackElementDecl,
4843 UnusedFileScopedDecls);
4855 for (
const auto &WeakUndeclaredIdentifierList :
4857 const IdentifierInfo *
const II = WeakUndeclaredIdentifierList.first;
4858 for (
const auto &WI : WeakUndeclaredIdentifierList.second) {
4872 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I) {
4882 AddDeclRef(TD, UnusedLocalTypedefNameCandidates);
4891 "There are local ones at end of translation unit!");
4908 for (
const auto &I : SemaRef.KnownNamespaces) {
4918 for (
const auto &I : Undefined) {
4928 for (
const auto &DeleteExprsInfo :
4930 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze);
4931 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());
4932 for (
const auto &DeleteLoc : DeleteExprsInfo.second) {
4934 DeleteExprsToAnalyze.push_back(DeleteLoc.second);
4940 WriteControlBlock(PP, Context, isysroot);
4943 Stream.FlushToWord();
4944 ASTBlockRange.first = Stream.GetCurrentBitNo() >> 3;
4946 ASTBlockStartOffset = Stream.GetCurrentBitNo();
4961 NewGlobalKindDeclPairs.push_back(D->
getKind());
4962 NewGlobalKindDeclPairs.push_back(
GetDeclRef(D));
4966 auto Abv = std::make_shared<BitCodeAbbrev>();
4968 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4969 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
4972 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev,
Record,
4973 bytes(NewGlobalKindDeclPairs));
4977 Abv = std::make_shared<BitCodeAbbrev>();
4979 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4980 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4981 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));
4982 WriteDeclContextVisibleUpdate(TU);
4985 if (Context.ExternCContext)
4986 WriteDeclContextVisibleUpdate(Context.ExternCContext);
5000 for (
const auto &Number : Context.MangleNumbers)
5001 if (!Number.first->isFromASTFile())
5004 for (
const auto &Number : Context.StaticLocalNumbers)
5005 if (!Number.first->isFromASTFile())
5012 for (
const auto *I : DeclsToEmitEvenIfUnreferenced) {
5026 llvm::sort(IIs, llvm::deref<std::less<>>());
5040 for (
auto &SelectorAndID : SelectorIDs)
5041 AllSelectors.push_back(SelectorAndID.first);
5042 for (
auto &
Selector : AllSelectors)
5051 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
5052 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
5053 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
5076 auto Abbrev = std::make_shared<BitCodeAbbrev>();
5078 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
5079 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
5082 llvm::raw_svector_ostream Out(Buffer);
5084 using namespace llvm::support;
5086 endian::Writer
LE(Out, llvm::endianness::little);
5087 LE.write<uint8_t>(
static_cast<uint8_t
>(M.
Kind));
5089 LE.write<uint16_t>(Name.size());
5090 Out.write(Name.data(), Name.size());
5094 uint32_t
None = std::numeric_limits<uint32_t>::max();
5096 auto writeBaseIDOrNone = [&](
auto BaseID,
bool ShouldWrite) {
5097 assert(BaseID < std::numeric_limits<uint32_t>::max() &&
"base id too high");
5099 LE.write<uint32_t>(BaseID);
5101 LE.write<uint32_t>(
None);
5118 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev,
Record,
5119 Buffer.data(), Buffer.size());
5124 for (
auto *D : SemaRef.DeclsToCheckForDeferredDiags)
5125 DeclsToCheckForDeferredDiags.push_back(
GetDeclRef(D));
5132 DeclTypesBlockStartOffset = Stream.GetCurrentBitNo();
5136 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord);
5137 while (!DeclTypesToEmit.empty()) {
5138 DeclOrType DOT = DeclTypesToEmit.front();
5139 DeclTypesToEmit.pop();
5141 WriteType(DOT.getType());
5143 WriteDecl(Context, DOT.getDecl());
5145 }
while (!DeclUpdates.empty());
5148 DoneWritingDeclsAndTypes =
true;
5151 WriteTypeDeclOffsets();
5152 if (!DeclUpdatesOffsetsRecord.empty())
5154 WriteFileDeclIDsMap();
5157 WritePreprocessor(PP, isModule);
5159 WriteSelectors(SemaRef);
5160 WriteReferencedSelectorsPool(SemaRef);
5161 WriteLateParsedTemplates(SemaRef);
5162 WriteIdentifierTable(PP, SemaRef.
IdResolver, isModule);
5164 WriteOpenCLExtensions(SemaRef);
5165 WriteCUDAPragmas(SemaRef);
5169 WriteSubmodules(WritingModule);
5174 if (!EagerlyDeserializedDecls.empty())
5177 if (!ModularCodegenDecls.empty())
5181 if (!TentativeDefinitions.empty())
5185 if (!UnusedFileScopedDecls.empty())
5189 if (!WeakUndeclaredIdentifiers.empty())
5191 WeakUndeclaredIdentifiers);
5194 if (!ExtVectorDecls.empty())
5198 if (!VTableUses.empty())
5202 if (!UnusedLocalTypedefNameCandidates.empty())
5204 UnusedLocalTypedefNameCandidates);
5207 if (!PendingInstantiations.empty())
5211 if (!SemaDeclRefs.empty())
5215 if (!DeclsToCheckForDeferredDiags.empty())
5217 DeclsToCheckForDeferredDiags);
5220 if (!CUDASpecialDeclRefs.empty())
5224 if (!DelegatingCtorDecls.empty())
5228 if (!KnownNamespaces.empty())
5232 if (!UndefinedButUsed.empty())
5235 if (!DeleteExprsToAnalyze.empty())
5239 for (
auto *DC : UpdatedDeclContexts)
5240 WriteDeclContextVisibleUpdate(DC);
5242 if (!WritingModule) {
5251 assert(SubmoduleIDs.contains(I->getImportedModule()));
5252 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
5253 I->getImportedModule()));
5256 if (!Imports.empty()) {
5257 auto Cmp = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5260 auto Eq = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5261 return A.ID == B.ID;
5265 llvm::sort(Imports, Cmp);
5266 Imports.erase(std::unique(Imports.begin(), Imports.end(),
Eq),
5270 for (
const auto &Import : Imports) {
5271 ImportedModules.push_back(
Import.ID);
5282 WriteObjCCategories();
5283 if(!WritingModule) {
5284 WriteOptimizePragmaOptions(SemaRef);
5285 WriteMSStructPragmaOptions(SemaRef);
5286 WriteMSPointersToMembersPragmaOptions(SemaRef);
5288 WritePackPragmaOptions(SemaRef);
5289 WriteFloatControlPragmaOptions(SemaRef);
5292 RecordData::value_type
Record[] = {
5293 NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts};
5296 Stream.FlushToWord();
5297 ASTBlockRange.second = Stream.GetCurrentBitNo() >> 3;
5300 for (
const auto &ExtWriter : ModuleFileExtensionWriters)
5301 WriteModuleFileExtension(SemaRef, *ExtWriter);
5303 return backpatchSignature();
5306void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
5307 if (DeclUpdates.empty())
5310 DeclUpdateMap LocalUpdates;
5311 LocalUpdates.swap(DeclUpdates);
5313 for (
auto &DeclUpdate : LocalUpdates) {
5314 const Decl *D = DeclUpdate.first;
5316 bool HasUpdatedBody =
false;
5317 bool HasAddedVarDefinition =
false;
5320 for (
auto &
Update : DeclUpdate.second) {
5326 HasUpdatedBody =
true;
5328 HasAddedVarDefinition =
true;
5336 assert(
Update.getDecl() &&
"no decl to add?");
5351 cast<ParmVarDecl>(
Update.getDecl())->getDefaultArg()));
5356 cast<FieldDecl>(
Update.getDecl())->getInClassInitializer());
5360 auto *RD = cast<CXXRecordDecl>(D);
5361 UpdatedDeclContexts.insert(RD->getPrimaryContext());
5362 Record.push_back(RD->isParamDestroyedInCallee());
5363 Record.push_back(llvm::to_underlying(RD->getArgPassingRestrictions()));
5364 Record.AddCXXDefinitionData(RD);
5365 Record.AddOffset(WriteDeclContextLexicalBlock(
5371 if (
auto *MSInfo = RD->getMemberSpecializationInfo()) {
5372 Record.push_back(MSInfo->getTemplateSpecializationKind());
5373 Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
5375 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
5376 Record.push_back(Spec->getTemplateSpecializationKind());
5377 Record.AddSourceLocation(Spec->getPointOfInstantiation());
5381 auto From = Spec->getInstantiatedFrom();
5382 if (
auto PartialSpec =
5385 Record.AddDeclRef(PartialSpec);
5386 Record.AddTemplateArgumentList(
5387 &Spec->getTemplateInstantiationArgs());
5392 Record.push_back(llvm::to_underlying(RD->getTagKind()));
5393 Record.AddSourceLocation(RD->getLocation());
5394 Record.AddSourceLocation(RD->getBeginLoc());
5395 Record.AddSourceRange(RD->getBraceRange());
5408 Record.AddStmt(cast<CXXDestructorDecl>(D)->getOperatorDeleteThisArg());
5414 Record.writeExceptionSpecInfo(prototype->getExceptionSpecInfo());
5432 D->
getAttr<OMPThreadPrivateDeclAttr>()->getRange());
5436 auto *A = D->
getAttr<OMPAllocateDeclAttr>();
5437 Record.push_back(A->getAllocatorType());
5438 Record.AddStmt(A->getAllocator());
5439 Record.AddStmt(A->getAlignment());
5440 Record.AddSourceRange(A->getRange());
5445 Record.push_back(D->
getAttr<OMPDeclareTargetDeclAttr>()->getMapType());
5447 D->
getAttr<OMPDeclareTargetDeclAttr>()->getRange());
5463 if (HasUpdatedBody) {
5464 const auto *Def = cast<FunctionDecl>(D);
5466 Record.push_back(Def->isInlined());
5467 Record.AddSourceLocation(Def->getInnerLocStart());
5468 Record.AddFunctionDefinition(Def);
5469 }
else if (HasAddedVarDefinition) {
5470 const auto *VD = cast<VarDecl>(D);
5472 Record.push_back(VD->isInline());
5473 Record.push_back(VD->isInlineSpecified());
5474 Record.AddVarDeclInit(VD);
5491 NonAffectingFileIDs.empty())
5493 auto It = llvm::lower_bound(NonAffectingFileIDs, FID);
5494 unsigned Idx = std::distance(NonAffectingFileIDs.begin(), It);
5495 unsigned Offset = NonAffectingFileIDAdjustments[Idx];
5496 return FileID::get(FID.getOpaqueValue() - Offset);
5499unsigned ASTWriter::getAdjustedNumCreatedFIDs(
FileID FID)
const {
5505 unsigned AdjustedNumCreatedFIDs = 0;
5506 for (
unsigned I = FID.ID, N = I + NumCreatedFIDs; I != N; ++I)
5507 if (IsSLocAffecting[I])
5508 ++AdjustedNumCreatedFIDs;
5509 return AdjustedNumCreatedFIDs;
5520 getAdjustedLocation(
Range.getEnd()));
5525 return Offset - getAdjustment(Offset);
5530 if (NonAffectingRanges.empty())
5536 if (Offset > NonAffectingRanges.back().getEnd().getOffset())
5537 return NonAffectingOffsetAdjustments.back();
5539 if (Offset < NonAffectingRanges.front().getBegin().getOffset())
5543 return Range.getEnd().getOffset() < Offset;
5546 auto It = llvm::lower_bound(NonAffectingRanges, Offset, Contains);
5547 unsigned Idx = std::distance(NonAffectingRanges.begin(), It);
5548 return NonAffectingOffsetAdjustments[Idx];
5552 Record.push_back(getAdjustedFileID(FID).getOpaqueValue());
5557 Loc = getAdjustedLocation(Loc);
5579 IdentID &ID = IdentifierIDs[II];
5595 MacroInfoToEmitData Info = { Name, MI, ID };
5596 MacroInfosToEmit.push_back(Info);
5605 assert(MacroIDs.contains(MI) &&
"Macro not emitted!");
5606 return MacroIDs[MI];
5610 return IdentMacroDirectivesOffsetMap.lookup(Name);
5614 Record->push_back(Writer->getSelectorRef(SelRef));
5623 if (SID == 0 && Chain) {
5627 SID = SelectorIDs[Sel];
5630 SID = NextSelectorID++;
5631 SelectorIDs[Sel] = SID;
5673 bool InfoHasSameExpr
5675 Record->push_back(InfoHasSameExpr);
5676 if (InfoHasSameExpr)
5694 TypeLocWriter TLW(*
this,
Seq);
5712 if (DoneWritingDeclsAndTypes) {
5713 assert(0 &&
"New type seen after serializing all the types to emit!");
5720 DeclTypesToEmit.push(T);
5733 TypeIdxMap::const_iterator I = TypeIdxs.find(T);
5734 assert(I != TypeIdxs.end() &&
"Type not emitted!");
5744 assert(WritingAST &&
"Cannot request a declaration ID before AST writing");
5755 assert(!(
reinterpret_cast<uintptr_t>(D) & 0x01) &&
"Invalid decl pointer");
5758 if (DoneWritingDeclsAndTypes) {
5759 assert(0 &&
"New decl seen after serializing all the decls to emit!");
5766 DeclTypesToEmit.push(
const_cast<Decl *
>(D));
5781 assert(DeclIDs.contains(D) &&
"Declaration not emitted!");
5785void ASTWriter::associateDeclWithFile(
const Decl *D,
DeclID ID) {
5800 if (isa<ParmVarDecl, TemplateTemplateParmDecl>(D))
5805 assert(
SM.isLocalSourceLocation(FileLoc));
5808 std::tie(FID, Offset) =
SM.getDecomposedLoc(FileLoc);
5811 assert(
SM.getSLocEntry(FID).isFile());
5812 assert(IsSLocAffecting[FID.ID]);
5814 std::unique_ptr<DeclIDInFileInfo> &Info = FileDeclIDs[FID];
5816 Info = std::make_unique<DeclIDInFileInfo>();
5818 std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID);
5819 LocDeclIDsTy &Decls = Info->DeclIDs;
5820 Decls.push_back(LocDecl);
5825 "expected an anonymous declaration");
5829 auto It = AnonymousDeclarationNumbers.find(D);
5830 if (It == AnonymousDeclarationNumbers.end()) {
5833 AnonymousDeclarationNumbers[ND] = Number;
5836 It = AnonymousDeclarationNumbers.find(D);
5837 assert(It != AnonymousDeclarationNumbers.end() &&
5838 "declaration not found within its lexical context");
5846 switch (Name.getNameKind()) {
5893 NestedNames.push_back(NNS);
5897 Record->push_back(NestedNames.size());
5898 while(!NestedNames.empty()) {
5899 NNS = NestedNames.pop_back_val();
5941 assert(TemplateParams &&
"No TemplateParams!");
5947 for (
const auto &
P : *TemplateParams)
5953 Record->push_back(
false);
5960 assert(TemplateArgs &&
"No TemplateArgs!");
5962 for (
int i = 0, e = TemplateArgs->
size(); i != e; ++i)
5968 assert(ASTTemplArgList &&
"No ASTTemplArgList!");
5980 I =
Set.begin(), E =
Set.end(); I != E; ++I) {
5982 Record->push_back(I.getAccess());
5990 Record->push_back(
Base.getAccessSpecifierAsWritten());
5991 Record->push_back(
Base.getInheritConstructors());
6004 for (
auto &
Base : Bases)
6022 for (
auto *
Init : CtorInits) {
6023 if (
Init->isBaseInitializer()) {
6027 }
else if (
Init->isDelegatingInitializer()) {
6030 }
else if (
Init->isMemberInitializer()){
6043 if (
Init->isWritten())
6057 auto &
Data = D->data();
6064 DefinitionBits.
addBit(ShouldSkipCheckingODR);
6066#define FIELD(Name, Width, Merge) \
6067 if (!DefinitionBits.canWriteNextNBits(Width)) { \
6068 Record->push_back(DefinitionBits); \
6069 DefinitionBits.reset(0); \
6071 DefinitionBits.addBits(Data.Name, Width);
6073#include "clang/AST/CXXRecordDeclDefinitionBits.def"
6076 Record->push_back(DefinitionBits);
6079 if (!ShouldSkipCheckingODR)
6084 bool ModulesDebugInfo =
6085 Writer->Context->getLangOpts().ModulesDebugInfo && !D->
isDependentType();
6086 Record->push_back(ModulesDebugInfo);
6087 if (ModulesDebugInfo)
6088 Writer->ModularCodegenDecls.push_back(Writer->GetDeclRef(D));
6093 Record->push_back(
Data.ComputedVisibleConversions);
6094 if (
Data.ComputedVisibleConversions)
6098 if (!
Data.IsLambda) {
6100 if (
Data.NumBases > 0)
6105 if (
Data.NumVBases > 0)
6110 auto &Lambda = D->getLambdaData();
6113 LambdaBits.
addBits(Lambda.DependencyKind, 2);
6114 LambdaBits.
addBit(Lambda.IsGenericLambda);
6115 LambdaBits.
addBits(Lambda.CaptureDefault, 2);
6116 LambdaBits.
addBits(Lambda.NumCaptures, 15);
6117 LambdaBits.
addBit(Lambda.HasKnownInternalLinkage);
6118 Record->push_back(LambdaBits);
6120 Record->push_back(Lambda.NumExplicitCaptures);
6121 Record->push_back(Lambda.ManglingNumber);
6126 for (
unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
6133 Record->push_back(CaptureBits);
6135 switch (
Capture.getCaptureKind()) {
6162 Val |= (ES->HasConstantInitialization ? 2 : 0);
6163 Val |= (ES->HasConstantDestruction ? 4 : 0);
6177void ASTWriter::ReaderInitialized(
ASTReader *Reader) {
6178 assert(Reader &&
"Cannot remove chain");
6179 assert((!Chain || Chain == Reader) &&
"Cannot replace chain");
6180 assert(FirstDeclID == NextDeclID &&
6181 FirstTypeID == NextTypeID &&
6182 FirstIdentID == NextIdentID &&
6183 FirstMacroID == NextMacroID &&
6184 FirstSubmoduleID == NextSubmoduleID &&
6185 FirstSelectorID == NextSelectorID &&
6186 "Setting chain after writing has started.");
6198 NextDeclID = FirstDeclID;
6199 NextTypeID = FirstTypeID;
6200 NextIdentID = FirstIdentID;
6201 NextMacroID = FirstMacroID;
6202 NextSelectorID = FirstSelectorID;
6203 NextSubmoduleID = FirstSubmoduleID;
6208 IdentID &StoredID = IdentifierIDs[II];
6215 MacroID &StoredID = MacroIDs[MI];
6226 TypeIdx &StoredIdx = TypeIdxs[T];
6240 assert(!MacroDefinitions.contains(MD));
6241 MacroDefinitions[MD] =
ID;
6245 assert(!SubmoduleIDs.contains(Mod));
6246 SubmoduleIDs[Mod] =
ID;
6249void ASTWriter::CompletedTagDefinition(
const TagDecl *D) {
6252 assert(!WritingAST &&
"Already writing the AST!");
6253 if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
6255 if (RD->isFromASTFile()) {
6260 "completed a tag from another module but not by instantiation?");
6261 DeclUpdates[RD].push_back(
6276void ASTWriter::AddedVisibleDecl(
const DeclContext *DC,
const Decl *D) {
6279 "Should not add lookup results to non-lookup contexts!");
6282 if (isa<TranslationUnitDecl>(DC))
6290 !isa<FunctionTemplateDecl>(D))
6300 assert(!WritingAST &&
"Already writing the AST!");
6301 if (UpdatedDeclContexts.insert(DC) && !cast<Decl>(DC)->isFromASTFile()) {
6305 llvm::append_range(DeclsToEmitEvenIfUnreferenced, DC->
decls());
6307 DeclsToEmitEvenIfUnreferenced.push_back(D);
6319 if (!isa<CXXMethodDecl>(D))
6324 assert(!WritingAST &&
"Already writing the AST!");
6328void ASTWriter::ResolvedExceptionSpec(
const FunctionDecl *FD) {
6330 assert(!DoneWritingDeclsAndTypes &&
"Already done writing updates!");
6337 ->castAs<FunctionProtoType>()
6338 ->getExceptionSpecType()))
6345 assert(!WritingAST &&
"Already writing the AST!");
6348 DeclUpdates[D].push_back(
6357 assert(!WritingAST &&
"Already writing the AST!");
6358 assert(
Delete &&
"Not given an operator delete");
6365void ASTWriter::CompletedImplicitDefinition(
const FunctionDecl *D) {
6367 assert(!WritingAST &&
"Already writing the AST!");
6375void ASTWriter::VariableDefinitionInstantiated(
const VarDecl *D) {
6377 assert(!WritingAST &&
"Already writing the AST!");
6384void ASTWriter::FunctionDefinitionInstantiated(
const FunctionDecl *D) {
6386 assert(!WritingAST &&
"Already writing the AST!");
6393void ASTWriter::InstantiationRequested(
const ValueDecl *D) {
6395 assert(!WritingAST &&
"Already writing the AST!");
6402 if (
auto *VD = dyn_cast<VarDecl>(D))
6403 POI = VD->getPointOfInstantiation();
6405 POI = cast<FunctionDecl>(D)->getPointOfInstantiation();
6409void ASTWriter::DefaultArgumentInstantiated(
const ParmVarDecl *D) {
6411 assert(!WritingAST &&
"Already writing the AST!");
6415 DeclUpdates[D].push_back(
6419void ASTWriter::DefaultMemberInitializerInstantiated(
const FieldDecl *D) {
6420 assert(!WritingAST &&
"Already writing the AST!");
6424 DeclUpdates[D].push_back(
6431 assert(!WritingAST &&
"Already writing the AST!");
6435 assert(IFD->
getDefinition() &&
"Category on a class without a definition?");
6436 ObjCClassesWithCategories.insert(
6440void ASTWriter::DeclarationMarkedUsed(
const Decl *D) {
6442 assert(!WritingAST &&
"Already writing the AST!");
6454void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(
const Decl *D) {
6456 assert(!WritingAST &&
"Already writing the AST!");
6463void ASTWriter::DeclarationMarkedOpenMPAllocate(
const Decl *D,
const Attr *A) {
6465 assert(!WritingAST &&
"Already writing the AST!");
6472void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(
const Decl *D,
6475 assert(!WritingAST &&
"Already writing the AST!");
6479 DeclUpdates[D].push_back(
6483void ASTWriter::RedefinedHiddenDefinition(
const NamedDecl *D,
Module *M) {
6485 assert(!WritingAST &&
"Already writing the AST!");
6490void ASTWriter::AddedAttributeToRecord(
const Attr *
Attr,
6493 assert(!WritingAST &&
"Already writing the AST!");
6494 if (!
Record->isFromASTFile())
6499void ASTWriter::AddedCXXTemplateSpecialization(
6501 assert(!WritingAST &&
"Already writing the AST!");
6508 DeclsToEmitEvenIfUnreferenced.push_back(D);
6511void ASTWriter::AddedCXXTemplateSpecialization(
6513 assert(!WritingAST &&
"Already writing the AST!");
6520 DeclsToEmitEvenIfUnreferenced.push_back(D);
6525 assert(!WritingAST &&
"Already writing the AST!");
6532 DeclsToEmitEvenIfUnreferenced.push_back(D);
6546#define GEN_CLANG_CLAUSE_CLASS
6547#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
6548#include "llvm/Frontend/OpenMP/OMP.inc"
6557 OMPClauseWriter(*this).writeClause(
C);
6560void OMPClauseWriter::writeClause(
OMPClause *
C) {
6561 Record.push_back(
unsigned(
C->getClauseKind()));
6563 Record.AddSourceLocation(
C->getBeginLoc());
6564 Record.AddSourceLocation(
C->getEndLoc());
6568 Record.push_back(uint64_t(
C->getCaptureRegion()));
6569 Record.AddStmt(
C->getPreInitStmt());
6573 VisitOMPClauseWithPreInit(
C);
6574 Record.AddStmt(
C->getPostUpdateExpr());
6577void OMPClauseWriter::VisitOMPIfClause(
OMPIfClause *
C) {
6578 VisitOMPClauseWithPreInit(
C);
6580 Record.AddSourceLocation(
C->getNameModifierLoc());
6581 Record.AddSourceLocation(
C->getColonLoc());
6582 Record.AddStmt(
C->getCondition());
6583 Record.AddSourceLocation(
C->getLParenLoc());
6587 VisitOMPClauseWithPreInit(
C);
6588 Record.AddStmt(
C->getCondition());
6589 Record.AddSourceLocation(
C->getLParenLoc());
6593 VisitOMPClauseWithPreInit(
C);
6594 Record.AddStmt(
C->getNumThreads());
6595 Record.AddSourceLocation(
C->getLParenLoc());
6599 Record.AddStmt(
C->getSafelen());
6600 Record.AddSourceLocation(
C->getLParenLoc());
6604 Record.AddStmt(
C->getSimdlen());
6605 Record.AddSourceLocation(
C->getLParenLoc());
6609 Record.push_back(
C->getNumSizes());
6610 for (
Expr *Size :
C->getSizesRefs())
6612 Record.AddSourceLocation(
C->getLParenLoc());
6618 Record.AddStmt(
C->getFactor());
6619 Record.AddSourceLocation(
C->getLParenLoc());
6623 Record.AddStmt(
C->getAllocator());
6624 Record.AddSourceLocation(
C->getLParenLoc());
6628 Record.AddStmt(
C->getNumForLoops());
6629 Record.AddSourceLocation(
C->getLParenLoc());
6633 Record.AddStmt(
C->getEventHandler());
6634 Record.AddSourceLocation(
C->getLParenLoc());
6638 Record.push_back(
unsigned(
C->getDefaultKind()));
6639 Record.AddSourceLocation(
C->getLParenLoc());
6640 Record.AddSourceLocation(
C->getDefaultKindKwLoc());
6644 Record.push_back(
unsigned(
C->getProcBindKind()));
6645 Record.AddSourceLocation(
C->getLParenLoc());
6646 Record.AddSourceLocation(
C->getProcBindKindKwLoc());
6650 VisitOMPClauseWithPreInit(
C);
6651 Record.push_back(
C->getScheduleKind());
6652 Record.push_back(
C->getFirstScheduleModifier());
6653 Record.push_back(
C->getSecondScheduleModifier());
6654 Record.AddStmt(
C->getChunkSize());
6655 Record.AddSourceLocation(
C->getLParenLoc());
6656 Record.AddSourceLocation(
C->getFirstScheduleModifierLoc());
6657 Record.AddSourceLocation(
C->getSecondScheduleModifierLoc());
6658 Record.AddSourceLocation(
C->getScheduleKindLoc());
6659 Record.AddSourceLocation(
C->getCommaLoc());
6663 Record.push_back(
C->getLoopNumIterations().size());
6664 Record.AddStmt(
C->getNumForLoops());
6665 for (
Expr *NumIter :
C->getLoopNumIterations())
6667 for (
unsigned I = 0, E =
C->getLoopNumIterations().size(); I <E; ++I)
6668 Record.AddStmt(
C->getLoopCounter(I));
6669 Record.AddSourceLocation(
C->getLParenLoc());
6683 Record.push_back(
C->isExtended() ? 1 : 0);
6684 if (
C->isExtended()) {
6685 Record.AddSourceLocation(
C->getLParenLoc());
6686 Record.AddSourceLocation(
C->getArgumentLoc());
6687 Record.writeEnum(
C->getDependencyKind());
6697 Record.AddSourceLocation(
C->getLParenLoc());
6698 Record.AddSourceLocation(
C->getFailParameterLoc());
6699 Record.writeEnum(
C->getFailParameter());
6721 Record.push_back(
C->varlist_size());
6722 for (
Expr *VE :
C->varlists())
6724 Record.writeBool(
C->getIsTarget());
6725 Record.writeBool(
C->getIsTargetSync());
6726 Record.AddSourceLocation(
C->getLParenLoc());
6727 Record.AddSourceLocation(
C->getVarLoc());
6731 Record.AddStmt(
C->getInteropVar());
6732 Record.AddSourceLocation(
C->getLParenLoc());
6733 Record.AddSourceLocation(
C->getVarLoc());
6737 Record.AddStmt(
C->getInteropVar());
6738 Record.AddSourceLocation(
C->getLParenLoc());
6739 Record.AddSourceLocation(
C->getVarLoc());
6743 VisitOMPClauseWithPreInit(
C);
6744 Record.AddStmt(
C->getCondition());
6745 Record.AddSourceLocation(
C->getLParenLoc());
6749 VisitOMPClauseWithPreInit(
C);
6750 Record.AddStmt(
C->getCondition());
6751 Record.AddSourceLocation(
C->getLParenLoc());
6755 VisitOMPClauseWithPreInit(
C);
6756 Record.AddStmt(
C->getThreadID());
6757 Record.AddSourceLocation(
C->getLParenLoc());
6761 Record.AddStmt(
C->getAlignment());
6762 Record.AddSourceLocation(
C->getLParenLoc());
6766 Record.push_back(
C->varlist_size());
6767 Record.AddSourceLocation(
C->getLParenLoc());
6768 for (
auto *VE :
C->varlists()) {
6771 for (
auto *VE :
C->private_copies()) {
6777 Record.push_back(
C->varlist_size());
6778 VisitOMPClauseWithPreInit(
C);
6779 Record.AddSourceLocation(
C->getLParenLoc());
6780 for (
auto *VE :
C->varlists()) {
6783 for (
auto *VE :
C->private_copies()) {
6786 for (
auto *VE :
C->inits()) {
6792 Record.push_back(
C->varlist_size());
6793 VisitOMPClauseWithPostUpdate(
C);
6794 Record.AddSourceLocation(
C->getLParenLoc());
6795 Record.writeEnum(
C->getKind());
6796 Record.AddSourceLocation(
C->getKindLoc());
6797 Record.AddSourceLocation(
C->getColonLoc());
6798 for (
auto *VE :
C->varlists())
6800 for (
auto *E :
C->private_copies())
6802 for (
auto *E :
C->source_exprs())
6804 for (
auto *E :
C->destination_exprs())
6806 for (
auto *E :
C->assignment_ops())
6811 Record.push_back(
C->varlist_size());
6812 Record.AddSourceLocation(
C->getLParenLoc());
6813 for (
auto *VE :
C->varlists())
6818 Record.push_back(
C->varlist_size());
6819 Record.writeEnum(
C->getModifier());
6820 VisitOMPClauseWithPostUpdate(
C);
6821 Record.AddSourceLocation(
C->getLParenLoc());
6822 Record.AddSourceLocation(
C->getModifierLoc());
6823 Record.AddSourceLocation(
C->getColonLoc());
6824 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
6825 Record.AddDeclarationNameInfo(
C->getNameInfo());
6826 for (
auto *VE :
C->varlists())
6828 for (
auto *VE :
C->privates())
6830 for (
auto *E :
C->lhs_exprs())
6832 for (
auto *E :
C->rhs_exprs())
6834 for (
auto *E :
C->reduction_ops())
6836 if (
C->getModifier() == clang::OMPC_REDUCTION_inscan) {
6837 for (
auto *E :
C->copy_ops())
6839 for (
auto *E :
C->copy_array_temps())
6841 for (
auto *E :
C->copy_array_elems())
6847 Record.push_back(
C->varlist_size());
6848 VisitOMPClauseWithPostUpdate(
C);
6849 Record.AddSourceLocation(
C->getLParenLoc());
6850 Record.AddSourceLocation(
C->getColonLoc());
6851 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
6852 Record.AddDeclarationNameInfo(
C->getNameInfo());
6853 for (
auto *VE :
C->varlists())
6855 for (
auto *VE :
C->privates())
6857 for (
auto *E :
C->lhs_exprs())
6859 for (
auto *E :
C->rhs_exprs())
6861 for (
auto *E :
C->reduction_ops())
6866 Record.push_back(
C->varlist_size());
6867 VisitOMPClauseWithPostUpdate(
C);
6868 Record.AddSourceLocation(
C->getLParenLoc());
6869 Record.AddSourceLocation(
C->getColonLoc());
6870 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
6871 Record.AddDeclarationNameInfo(
C->getNameInfo());
6872 for (
auto *VE :
C->varlists())
6874 for (
auto *VE :
C->privates())
6876 for (
auto *E :
C->lhs_exprs())
6878 for (
auto *E :
C->rhs_exprs())
6880 for (
auto *E :
C->reduction_ops())
6882 for (
auto *E :
C->taskgroup_descriptors())
6887 Record.push_back(
C->varlist_size());
6888 VisitOMPClauseWithPostUpdate(
C);
6889 Record.AddSourceLocation(
C->getLParenLoc());
6890 Record.AddSourceLocation(
C->getColonLoc());
6891 Record.push_back(
C->getModifier());
6892 Record.AddSourceLocation(
C->getModifierLoc());
6893 for (
auto *VE :
C->varlists()) {
6896 for (
auto *VE :
C->privates()) {
6899 for (
auto *VE :
C->inits()) {
6902 for (
auto *VE :
C->updates()) {
6905 for (
auto *VE :
C->finals()) {
6909 Record.AddStmt(
C->getCalcStep());
6910 for (
auto *VE :
C->used_expressions())
6915 Record.push_back(
C->varlist_size());
6916 Record.AddSourceLocation(
C->getLParenLoc());
6917 Record.AddSourceLocation(
C->getColonLoc());
6918 for (
auto *VE :
C->varlists())
6920 Record.AddStmt(
C->getAlignment());
6924 Record.push_back(
C->varlist_size());
6925 Record.AddSourceLocation(
C->getLParenLoc());
6926 for (
auto *VE :
C->varlists())
6928 for (
auto *E :
C->source_exprs())
6930 for (
auto *E :
C->destination_exprs())
6932 for (
auto *E :
C->assignment_ops())
6937 Record.push_back(
C->varlist_size());
6938 Record.AddSourceLocation(
C->getLParenLoc());
6939 for (
auto *VE :
C->varlists())
6941 for (
auto *E :
C->source_exprs())
6943 for (
auto *E :
C->destination_exprs())
6945 for (
auto *E :
C->assignment_ops())
6950 Record.push_back(
C->varlist_size());
6951 Record.AddSourceLocation(
C->getLParenLoc());
6952 for (
auto *VE :
C->varlists())
6957 Record.AddStmt(
C->getDepobj());
6958 Record.AddSourceLocation(
C->getLParenLoc());
6962 Record.push_back(
C->varlist_size());
6963 Record.push_back(
C->getNumLoops());
6964 Record.AddSourceLocation(
C->getLParenLoc());
6965 Record.AddStmt(
C->getModifier());
6966 Record.push_back(
C->getDependencyKind());
6967 Record.AddSourceLocation(
C->getDependencyLoc());
6968 Record.AddSourceLocation(
C->getColonLoc());
6969 Record.AddSourceLocation(
C->getOmpAllMemoryLoc());
6970 for (
auto *VE :
C->varlists())
6972 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
6973 Record.AddStmt(
C->getLoopData(I));
6977 VisitOMPClauseWithPreInit(
C);
6978 Record.writeEnum(
C->getModifier());
6979 Record.AddStmt(
C->getDevice());
6980 Record.AddSourceLocation(
C->getModifierLoc());
6981 Record.AddSourceLocation(
C->getLParenLoc());
6985 Record.push_back(
C->varlist_size());
6986 Record.push_back(
C->getUniqueDeclarationsNum());
6987 Record.push_back(
C->getTotalComponentListNum());
6988 Record.push_back(
C->getTotalComponentsNum());
6989 Record.AddSourceLocation(
C->getLParenLoc());
6990 bool HasIteratorModifier =
false;
6992 Record.push_back(
C->getMapTypeModifier(I));
6993 Record.AddSourceLocation(
C->getMapTypeModifierLoc(I));
6994 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
6995 HasIteratorModifier =
true;
6997 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
6998 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
6999 Record.push_back(
C->getMapType());
7000 Record.AddSourceLocation(
C->getMapLoc());
7001 Record.AddSourceLocation(
C->getColonLoc());
7002 for (
auto *E :
C->varlists())
7004 for (
auto *E :
C->mapperlists())
7006 if (HasIteratorModifier)
7007 Record.AddStmt(
C->getIteratorModifier());
7008 for (
auto *D :
C->all_decls())
7010 for (
auto N :
C->all_num_lists())
7012 for (
auto N :
C->all_lists_sizes())
7014 for (
auto &M :
C->all_components()) {
7015 Record.AddStmt(M.getAssociatedExpression());
7016 Record.AddDeclRef(M.getAssociatedDeclaration());
7021 Record.push_back(
C->varlist_size());
7022 Record.AddSourceLocation(
C->getLParenLoc());
7023 Record.AddSourceLocation(
C->getColonLoc());
7024 Record.AddStmt(
C->getAllocator());
7025 for (
auto *VE :
C->varlists())
7030 VisitOMPClauseWithPreInit(
C);
7031 Record.AddStmt(
C->getNumTeams());
7032 Record.AddSourceLocation(
C->getLParenLoc());
7036 VisitOMPClauseWithPreInit(
C);
7037 Record.AddStmt(
C->getThreadLimit());
7038 Record.AddSourceLocation(
C->getLParenLoc());
7042 VisitOMPClauseWithPreInit(
C);
7043 Record.AddStmt(
C->getPriority());
7044 Record.AddSourceLocation(
C->getLParenLoc());
7048 VisitOMPClauseWithPreInit(
C);
7049 Record.writeEnum(
C->getModifier());
7050 Record.AddStmt(
C->getGrainsize());
7051 Record.AddSourceLocation(
C->getModifierLoc());
7052 Record.AddSourceLocation(
C->getLParenLoc());
7056 VisitOMPClauseWithPreInit(
C);
7057 Record.writeEnum(
C->getModifier());
7058 Record.AddStmt(
C->getNumTasks());
7059 Record.AddSourceLocation(
C->getModifierLoc());
7060 Record.AddSourceLocation(
C->getLParenLoc());
7065 Record.AddSourceLocation(
C->getLParenLoc());
7069 VisitOMPClauseWithPreInit(
C);
7070 Record.push_back(
C->getDistScheduleKind());
7071 Record.AddStmt(
C->getChunkSize());
7072 Record.AddSourceLocation(
C->getLParenLoc());
7073 Record.AddSourceLocation(
C->getDistScheduleKindLoc());
7074 Record.AddSourceLocation(
C->getCommaLoc());
7078 Record.push_back(
C->getDefaultmapKind());
7079 Record.push_back(
C->getDefaultmapModifier());
7080 Record.AddSourceLocation(
C->getLParenLoc());
7081 Record.AddSourceLocation(
C->getDefaultmapModifierLoc());
7082 Record.AddSourceLocation(
C->getDefaultmapKindLoc());
7085void OMPClauseWriter::VisitOMPToClause(
OMPToClause *
C) {
7086 Record.push_back(
C->varlist_size());
7087 Record.push_back(
C->getUniqueDeclarationsNum());
7088 Record.push_back(
C->getTotalComponentListNum());
7089 Record.push_back(
C->getTotalComponentsNum());
7090 Record.AddSourceLocation(
C->getLParenLoc());
7092 Record.push_back(
C->getMotionModifier(I));
7093 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
7095 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7096 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7097 Record.AddSourceLocation(
C->getColonLoc());
7098 for (
auto *E :
C->varlists())
7100 for (
auto *E :
C->mapperlists())
7102 for (
auto *D :
C->all_decls())
7104 for (
auto N :
C->all_num_lists())
7106 for (
auto N :
C->all_lists_sizes())
7108 for (
auto &M :
C->all_components()) {
7109 Record.AddStmt(M.getAssociatedExpression());
7110 Record.writeBool(M.isNonContiguous());
7111 Record.AddDeclRef(M.getAssociatedDeclaration());
7116 Record.push_back(
C->varlist_size());
7117 Record.push_back(
C->getUniqueDeclarationsNum());
7118 Record.push_back(
C->getTotalComponentListNum());
7119 Record.push_back(
C->getTotalComponentsNum());
7120 Record.AddSourceLocation(
C->getLParenLoc());
7122 Record.push_back(
C->getMotionModifier(I));
7123 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
7125 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7126 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7127 Record.AddSourceLocation(
C->getColonLoc());
7128 for (
auto *E :
C->varlists())
7130 for (
auto *E :
C->mapperlists())
7132 for (
auto *D :
C->all_decls())
7134 for (
auto N :
C->all_num_lists())
7136 for (
auto N :
C->all_lists_sizes())
7138 for (
auto &M :
C->all_components()) {
7139 Record.AddStmt(M.getAssociatedExpression());
7140 Record.writeBool(M.isNonContiguous());
7141 Record.AddDeclRef(M.getAssociatedDeclaration());
7146 Record.push_back(
C->varlist_size());
7147 Record.push_back(
C->getUniqueDeclarationsNum());
7148 Record.push_back(
C->getTotalComponentListNum());
7149 Record.push_back(
C->getTotalComponentsNum());
7150 Record.AddSourceLocation(
C->getLParenLoc());
7151 for (
auto *E :
C->varlists())
7153 for (
auto *VE :
C->private_copies())
7155 for (
auto *VE :
C->inits())
7157 for (
auto *D :
C->all_decls())
7159 for (
auto N :
C->all_num_lists())
7161 for (
auto N :
C->all_lists_sizes())
7163 for (
auto &M :
C->all_components()) {
7164 Record.AddStmt(M.getAssociatedExpression());
7165 Record.AddDeclRef(M.getAssociatedDeclaration());
7170 Record.push_back(
C->varlist_size());
7171 Record.push_back(
C->getUniqueDeclarationsNum());
7172 Record.push_back(
C->getTotalComponentListNum());
7173 Record.push_back(
C->getTotalComponentsNum());
7174 Record.AddSourceLocation(
C->getLParenLoc());
7175 for (
auto *E :
C->varlists())
7177 for (
auto *D :
C->all_decls())
7179 for (
auto N :
C->all_num_lists())
7181 for (
auto N :
C->all_lists_sizes())
7183 for (
auto &M :
C->all_components()) {
7184 Record.AddStmt(M.getAssociatedExpression());
7185 Record.AddDeclRef(M.getAssociatedDeclaration());
7190 Record.push_back(
C->varlist_size());
7191 Record.push_back(
C->getUniqueDeclarationsNum());
7192 Record.push_back(
C->getTotalComponentListNum());
7193 Record.push_back(
C->getTotalComponentsNum());
7194 Record.AddSourceLocation(
C->getLParenLoc());
7195 for (
auto *E :
C->varlists())
7197 for (
auto *D :
C->all_decls())
7199 for (
auto N :
C->all_num_lists())
7201 for (
auto N :
C->all_lists_sizes())
7203 for (
auto &M :
C->all_components()) {
7204 Record.AddStmt(M.getAssociatedExpression());
7205 Record.AddDeclRef(M.getAssociatedDeclaration());
7210 Record.push_back(
C->varlist_size());
7211 Record.push_back(
C->getUniqueDeclarationsNum());
7212 Record.push_back(
C->getTotalComponentListNum());
7213 Record.push_back(
C->getTotalComponentsNum());
7214 Record.AddSourceLocation(
C->getLParenLoc());
7215 for (
auto *E :
C->varlists())
7217 for (
auto *D :
C->all_decls())
7219 for (
auto N :
C->all_num_lists())
7221 for (
auto N :
C->all_lists_sizes())
7223 for (
auto &M :
C->all_components()) {
7224 Record.AddStmt(M.getAssociatedExpression());
7225 Record.AddDeclRef(M.getAssociatedDeclaration());
7231void OMPClauseWriter::VisitOMPUnifiedSharedMemoryClause(
7240void OMPClauseWriter::VisitOMPAtomicDefaultMemOrderClause(
7242 Record.push_back(
C->getAtomicDefaultMemOrderKind());
7243 Record.AddSourceLocation(
C->getLParenLoc());
7244 Record.AddSourceLocation(
C->getAtomicDefaultMemOrderKindKwLoc());
7247void OMPClauseWriter::VisitOMPAtClause(
OMPAtClause *
C) {
7248 Record.push_back(
C->getAtKind());
7249 Record.AddSourceLocation(
C->getLParenLoc());
7250 Record.AddSourceLocation(
C->getAtKindKwLoc());
7254 Record.push_back(
C->getSeverityKind());
7255 Record.AddSourceLocation(
C->getLParenLoc());
7256 Record.AddSourceLocation(
C->getSeverityKindKwLoc());
7260 Record.AddStmt(
C->getMessageString());
7261 Record.AddSourceLocation(
C->getLParenLoc());
7265 Record.push_back(
C->varlist_size());
7266 Record.AddSourceLocation(
C->getLParenLoc());
7267 for (
auto *VE :
C->varlists())
7269 for (
auto *E :
C->private_refs())
7274 Record.push_back(
C->varlist_size());
7275 Record.AddSourceLocation(
C->getLParenLoc());
7276 for (
auto *VE :
C->varlists())
7281 Record.push_back(
C->varlist_size());
7282 Record.AddSourceLocation(
C->getLParenLoc());
7283 for (
auto *VE :
C->varlists())
7288 Record.writeEnum(
C->getKind());
7289 Record.writeEnum(
C->getModifier());
7290 Record.AddSourceLocation(
C->getLParenLoc());
7291 Record.AddSourceLocation(
C->getKindKwLoc());
7292 Record.AddSourceLocation(
C->getModifierKwLoc());
7296 Record.push_back(
C->getNumberOfAllocators());
7297 Record.AddSourceLocation(
C->getLParenLoc());
7298 for (
unsigned I = 0, E =
C->getNumberOfAllocators(); I < E; ++I) {
7308 Record.push_back(
C->varlist_size());
7309 Record.AddSourceLocation(
C->getLParenLoc());
7310 Record.AddStmt(
C->getModifier());
7311 Record.AddSourceLocation(
C->getColonLoc());
7312 for (
Expr *E :
C->varlists())
7317 Record.writeEnum(
C->getBindKind());
7318 Record.AddSourceLocation(
C->getLParenLoc());
7319 Record.AddSourceLocation(
C->getBindKindLoc());
7323 VisitOMPClauseWithPreInit(
C);
7325 Record.AddSourceLocation(
C->getLParenLoc());
7329 Record.push_back(
C->varlist_size());
7330 Record.push_back(
C->getNumLoops());
7331 Record.AddSourceLocation(
C->getLParenLoc());
7332 Record.push_back(
C->getDependenceType());
7333 Record.AddSourceLocation(
C->getDependenceLoc());
7334 Record.AddSourceLocation(
C->getColonLoc());
7335 for (
auto *VE :
C->varlists())
7337 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
7338 Record.AddStmt(
C->getLoopData(I));
7342 Record.AddAttributes(
C->getAttrs());
7343 Record.AddSourceLocation(
C->getBeginLoc());
7344 Record.AddSourceLocation(
C->getLParenLoc());
7345 Record.AddSourceLocation(
C->getEndLoc());
7352 for (
const auto &
Set : TI->
Sets) {
7359 writeExprRef(
Selector.ScoreOrCondition);
7373 for (
unsigned I = 0, E =
Data->getNumClauses(); I < E; ++I)
7375 if (
Data->hasAssociatedStmt())
7377 for (
unsigned I = 0, E =
Data->getNumChildren(); I < E; ++I)
Defines the clang::ASTContext interface.
static bool isInterestingIdentifier(ASTReader &Reader, 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 void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, ASTWriter::RecordData &Record)
static uint64_t EmitCXXCtorInitializers(ASTWriter &W, ArrayRef< CXXCtorInitializer * > CtorInits)
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 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 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(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 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 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 the clang::OpenCLOptions class.
This file defines OpenMP AST classes for clauses.
Defines the clang::Preprocessor interface.
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 BLOCK(DERIVED, BASE)
C Language Family Type Representation.
Defines version macros and version-related utility functions for Clang.
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 ...
SourceManager & getSourceManager()
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.
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
FunctionDecl * getcudaConfigureCallDecl()
DiagnosticsEngine & getDiagnostics() const
const TargetInfo & getTargetInfo() const
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.
unsigned getTotalNumIdentifiers() const
Returns the number of identifiers found in the chain.
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 getTotalNumTypes() const
Returns the number of types 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()
unsigned getTotalNumMacros() const
Returns the number of macros found in the chain.
unsigned getTotalNumDecls() const
Returns the number of declarations 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 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 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 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 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 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.
ASTFileSignature WriteAST(Sema &SemaRef, StringRef OutputFile, Module *WritingModule, StringRef isysroot, bool ShouldCacheASTInMemory=false)
Write a precompiled header for the given semantic analysis.
serialization::TypeID getTypeID(QualType T) const
Determine the type ID of an already-emitted type.
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.
serialization::DeclID GetDeclRef(const Decl *D)
Force a declaration to be emitted and get its ID.
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.
uint32_t getMacroDirectivesOffset(const IdentifierInfo *Name)
void AddAlignPackInfo(const Sema::AlignPackInfo &Info, RecordDataImpl &Record)
Emit a AlignPackInfo.
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 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.
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
serialization::TypeID GetOrCreateTypeID(QualType T)
Force a type to be emitted and get its ID.
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.
void AddTypeRef(QualType T, RecordDataImpl &Record)
Emit a reference to a type.
ASTReader * getChain() const
serialization::DeclID getDeclID(const Decl *D)
Determine the declaration ID of an already-emitted declaration.
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.
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
unsigned getAnonymousDeclarationNumber(const NamedDecl *D)
serialization::IdentID getIdentifierRef(const IdentifierInfo *II)
Get the unique number used to refer to the given identifier.
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.
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
Represents a base class of a C++ class.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
unsigned getDeviceLambdaManglingNumber() const
Retrieve the device side mangling number.
unsigned getODRHash() const
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.
StoredDeclsMap * getLookupPtr() const
Retrieve the internal representation of the lookup structure.
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 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.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
SourceLocation getLocation() const
bool shouldSkipCheckingODR() const
Check if we should skip checking ODRHash for declaration.
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
unsigned getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
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.
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror.
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).
time_t getModificationTime() const
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
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.
OptionalFileEntryRef getContainingModuleMapFile(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
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...
OptionalFileEntryRef getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this 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.
SmallVector< Header, 2 > Headers[5]
The headers that are part of this 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.
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.
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 '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 'shedule', 'firstprivate' etc.
This is a basic class for representing single OpenMP clause.
This represents 'collapse' clause in the '#pragma omp ...' directive.
This represents 'compare' clause in the '#pragma omp atomic' directive.
This represents clause 'copyin' in the '#pragma omp ...' directives.
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 '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 '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 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' directive.
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
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
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
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.
bool hasLocalNonFastQualifiers() const
Determine whether this particular QualType instance has any "non-fast" qualifiers,...
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
unsigned getLocalFastQualifiers() const
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
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.
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.
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
void * getAsOpaquePtr() const
unsigned getNumArgs() const
static uint32_t getRawEncoding(const AlignPackInfo &Info)
llvm::DenseMap< Selector, Lists >::iterator iterator
iterator find(Selector Sel)
Sema - This implements semantic analysis and AST building for C.
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
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...
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.
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.
void updateOutOfDateSelector(Selector Sel)
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...
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
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 uint64_t encode(SourceLocation Loc, 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.
SourceLocation::UIntTy getNextLocalOffset() const
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
FileID translateFile(const FileEntry *SourceFile) const
Get the FileID for the given file.
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.
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include'd file otherwise it returns an invalid location.
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 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.
SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const
Return the file characteristic of the specified source location, indicating whether this is a normal ...
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
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.
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
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::IdentID BaseIdentifierID
Base identifier ID for identifiers local to this module.
serialization::DeclID BaseDeclID
Base declaration ID for declarations local to this module.
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
serialization::TypeID BaseTypeIndex
Base type ID for types local to this module as represented in the global type ID space.
unsigned LocalNumIdentifiers
The number of identifiers in this AST file.
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 LocalNumSLocEntries
The number of source location entries in this AST file.
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
unsigned LocalNumTypes
The number of types in this AST file.
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 LocalNumDecls
The number of declarations 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.
Manages the set of modules loaded by an AST reader.
Writer for the on-disk hash table.
A type index; the type ID with the qualifier bits removed.
uint32_t getIndex() const
Class that performs name lookup into a DeclContext stored in an AST file.
PredefinedDeclIDs
Predefined declaration IDs.
const unsigned int LOCAL_REDECLARATIONS
Record code for a list of local redeclarations of a declaration.
const unsigned NUM_PREDEF_TYPE_IDS
The number of predefined type IDs that are reserved for the PREDEF_TYPE_* constants.
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
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_DECL_OBJC_SEL_ID
The Objective-C 'SEL' type.
@ PREDEF_DECL_UNSIGNED_INT_128_ID
The unsigned 128-bit integer type.
@ PREDEF_DECL_OBJC_CLASS_ID
The Objective-C 'Class' type.
@ PREDEF_DECL_OBJC_ID_ID
The Objective-C 'id' type.
@ PREDEF_DECL_INT_128_ID
The signed 128-bit integer type.
@ PREDEF_DECL_OBJC_INSTANCETYPE_ID
The internal 'instancetype' typedef.
@ PREDEF_DECL_BUILTIN_MS_GUID_ID
The predeclared '_GUID' struct.
@ PREDEF_DECL_MAKE_INTEGER_SEQ_ID
The internal '__make_integer_seq' template.
@ PREDEF_DECL_EXTERN_C_CONTEXT_ID
The extern "C" context.
@ PREDEF_DECL_OBJC_PROTOCOL_ID
The Objective-C 'Protocol' type.
@ PREDEF_DECL_TYPE_PACK_ELEMENT_ID
The internal '__type_pack_element' template.
@ PREDEF_DECL_BUILTIN_MS_VA_LIST_ID
The internal '__builtin_ms_va_list' typedef.
@ PREDEF_DECL_BUILTIN_VA_LIST_ID
The internal '__builtin_va_list' typedef.
@ PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID
The internal '__NSConstantString' tag type.
@ PREDEF_DECL_TRANSLATION_UNIT_ID
The translation unit.
@ PREDEF_DECL_VA_LIST_TAG
The internal '__va_list_tag' struct, if any.
@ PREDEF_DECL_CF_CONSTANT_STRING_ID
The internal '__NSConstantString' typedef.
@ CTOR_INITIALIZER_MEMBER
@ CTOR_INITIALIZER_DELEGATING
@ CTOR_INITIALIZER_INDIRECT_MEMBER
@ DECL_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_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_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)
@ EXTENSION_METADATA
Metadata describing this particular extension.
uint32_t TypeID
An ID number that refers to a type in an AST file.
@ SUBMODULE_EXCLUDED_HEADER
Specifies a header that has been explicitly excluded from this submodule.
@ SUBMODULE_TOPHEADER
Specifies a top-level header that falls into this (sub)module.
@ SUBMODULE_PRIVATE_TEXTUAL_HEADER
Specifies a header that is private to this submodule but must be textually included.
@ SUBMODULE_HEADER
Specifies a header that falls into this (sub)module.
@ SUBMODULE_EXPORT_AS
Specifies the name of the module that will eventually re-export the entities in this module.
@ SUBMODULE_UMBRELLA_DIR
Specifies an umbrella directory.
@ SUBMODULE_UMBRELLA_HEADER
Specifies the umbrella header used to create this module, if any.
@ SUBMODULE_METADATA
Metadata for submodules as a whole.
@ SUBMODULE_REQUIRES
Specifies a required feature.
@ SUBMODULE_PRIVATE_HEADER
Specifies a header that is private to this submodule.
@ SUBMODULE_IMPORTS
Specifies the submodules that are imported by this submodule.
@ SUBMODULE_CONFLICT
Specifies a conflict with another module.
@ SUBMODULE_INITIALIZERS
Specifies some declarations with initializers that must be emitted to initialize the module.
@ SUBMODULE_DEFINITION
Defines the major attributes of a submodule, including its name and parent.
@ SUBMODULE_LINK_LIBRARY
Specifies a library or framework to link against.
@ SUBMODULE_CONFIG_MACRO
Specifies a configuration macro for this module.
@ SUBMODULE_EXPORTS
Specifies the submodules that are re-exported from this submodule.
@ SUBMODULE_TEXTUAL_HEADER
Specifies a header that is part of the module but must be textually included.
@ SUBMODULE_AFFECTING_MODULES
Specifies affecting modules that were not imported.
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
@ FILE_SYSTEM_OPTIONS
Record code for the filesystem options table.
@ TARGET_OPTIONS
Record code for the target options table.
@ PREPROCESSOR_OPTIONS
Record code for the preprocessor options table.
@ HEADER_SEARCH_OPTIONS
Record code for the headers search options table.
@ LANGUAGE_OPTIONS
Record code for the language options table.
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
@ SUBMODULE_BLOCK_ID
The block containing the submodule structure.
@ PREPROCESSOR_DETAIL_BLOCK_ID
The block containing the detailed preprocessing record.
@ AST_BLOCK_ID
The AST block, which acts as a container around the full AST block.
@ SOURCE_MANAGER_BLOCK_ID
The block containing information about the source manager.
@ CONTROL_BLOCK_ID
The control block, which contains all of the information that needs to be validated prior to committi...
@ DECLTYPES_BLOCK_ID
The block containing the definitions of all of the types and decls used within the AST file.
@ PREPROCESSOR_BLOCK_ID
The block containing information about the preprocessor.
@ COMMENTS_BLOCK_ID
The block containing comments.
@ UNHASHED_CONTROL_BLOCK_ID
A block with unhashed content.
@ EXTENSION_BLOCK_ID
A block containing a module file extension.
@ OPTIONS_BLOCK_ID
The block of configuration options, used to check that a module is being used in a configuration comp...
@ INPUT_FILES_BLOCK_ID
The block of input files, which were used as inputs to create this AST file.
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
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.
TypeID MakeTypeID(ASTContext &Context, QualType T, IdxForTypeTy IdxForType)
@ 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.
@ IMPORTS
Record code for the list of other AST files imported by this AST file.
@ ORIGINAL_FILE_ID
Record code for file ID of the file or buffer that was used to generate the AST file.
@ MODULE_NAME
Record code for the module name.
@ ORIGINAL_FILE
Record code for the original file that was used to generate the AST file, including both its file ID ...
@ INPUT_FILE_OFFSETS
Offsets into the input-files block where input files reside.
@ METADATA
AST file metadata, including the AST file version number and information about the compiler used to b...
@ DIAGNOSTIC_OPTIONS
Record code for the diagnostic options table.
@ HEADER_SEARCH_ENTRY_USAGE
Record code for the indices of used header search entries.
@ AST_BLOCK_HASH
Record code for the content hash of the AST block.
@ DIAG_PRAGMA_MAPPINGS
Record code for #pragma diagnostic mappings.
@ SIGNATURE
Record code for the signature that identifiers this AST file.
@ HEADER_SEARCH_PATHS
Record code for the headers search paths.
@ VFS_USAGE
Record code for the indices of used VFSs.
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
@ 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...
@ 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.
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.
@ TYPE_OFFSET
Record code for the offsets of each type.
@ DELEGATING_CTORS
The list of delegating constructor declarations.
@ PP_ASSUME_NONNULL_LOC
ID 66 used to be the list of included files.
@ EXT_VECTOR_DECLS
Record code for the set of ext_vector type names.
@ OPENCL_EXTENSIONS
Record code for enabled OpenCL extensions.
@ FP_PRAGMA_OPTIONS
Record code for floating point #pragma options.
@ VTABLE_USES
Record code for the array of VTable uses.
@ LATE_PARSED_TEMPLATE
Record code for late parsed template functions.
@ DECLS_TO_CHECK_FOR_DEFERRED_DIAGS
Record code for the Decls to be checked for deferred diags.
@ DECL_OFFSET
Record code for the offsets of each decl.
@ SOURCE_MANAGER_LINE_TABLE
Record code for the source manager line table information, which stores information about #line direc...
@ PP_COUNTER_VALUE
The value of the next COUNTER to dispense.
@ DELETE_EXPRS_TO_ANALYZE
Delete expressions that will be analyzed later.
@ UPDATE_VISIBLE
Record code for an update to a decl context's lookup table.
@ CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH
Number of unmatched #pragma clang cuda_force_host_device begin directives we've seen.
@ MACRO_OFFSET
Record code for the table of offsets of each macro ID.
@ PPD_ENTITIES_OFFSETS
Record code for the table of offsets to entries in the preprocessing record.
@ OPENCL_EXTENSION_DECLS
Record code for declarations associated with OpenCL extensions.
@ IDENTIFIER_OFFSET
Record code for the table of offsets of each identifier ID.
@ OBJC_CATEGORIES
Record code for the array of Objective-C categories (including extensions).
@ METHOD_POOL
Record code for the Objective-C method pool,.
@ PP_CONDITIONAL_STACK
The stack of open #ifs/#ifdefs recorded in a preamble.
@ REFERENCED_SELECTOR_POOL
Record code for referenced selector pool.
@ SOURCE_LOCATION_OFFSETS
Record code for the table of offsets into the block of source-location information.
@ WEAK_UNDECLARED_IDENTIFIERS
Record code for weak undeclared identifiers.
@ UNDEFINED_BUT_USED
Record code for undefined but used functions and variables that need a definition in this TU.
@ FILE_SORTED_DECLS
Record code for a file sorted array of DeclIDs in a module.
@ MSSTRUCT_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
@ TENTATIVE_DEFINITIONS
Record code for the array of tentative definitions.
@ UNUSED_FILESCOPED_DECLS
Record code for the array of unused file scoped decls.
@ ALIGN_PACK_PRAGMA_OPTIONS
Record code for #pragma align/pack options.
@ IMPORTED_MODULES
Record code for an array of all of the (sub)modules that were imported by the AST file.
@ SELECTOR_OFFSETS
Record code for the table of offsets into the Objective-C method pool.
@ UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES
Record code for potentially unused local typedef names.
@ 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_TEMPLATE_SPECIALIZATION
@ 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.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ Delete
'delete' clause, allowed on the 'exit data' construct.
@ NUM_OVERLOADED_OPERATORS
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
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.
for(auto typeArg :T->getTypeArgsAsWritten())
static constexpr unsigned NumberOfOMPMapClauseModifiers
Number of allowed map-type-modifiers.
@ 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.
static constexpr unsigned NumberOfOMPMotionModifiers
Number of allowed motion-modifiers.
llvm::hash_code hash_value(const CustomizableOptional< T > &O)
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.
YAML serialization mapping.
__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.
Source range/offset of a preprocessed entity.