78#include "llvm/ADT/APFloat.h"
79#include "llvm/ADT/APInt.h"
80#include "llvm/ADT/APSInt.h"
81#include "llvm/ADT/ArrayRef.h"
82#include "llvm/ADT/DenseMap.h"
83#include "llvm/ADT/Hashing.h"
84#include "llvm/ADT/PointerIntPair.h"
85#include "llvm/ADT/STLExtras.h"
86#include "llvm/ADT/ScopeExit.h"
87#include "llvm/ADT/SmallPtrSet.h"
88#include "llvm/ADT/SmallString.h"
89#include "llvm/ADT/SmallVector.h"
90#include "llvm/ADT/StringMap.h"
91#include "llvm/ADT/StringRef.h"
92#include "llvm/Bitstream/BitCodes.h"
93#include "llvm/Bitstream/BitstreamWriter.h"
94#include "llvm/Support/Casting.h"
95#include "llvm/Support/Compression.h"
96#include "llvm/Support/DJB.h"
97#include "llvm/Support/Endian.h"
98#include "llvm/Support/EndianStream.h"
99#include "llvm/Support/Error.h"
100#include "llvm/Support/ErrorHandling.h"
101#include "llvm/Support/LEB128.h"
102#include "llvm/Support/MemoryBuffer.h"
103#include "llvm/Support/OnDiskHashTable.h"
104#include "llvm/Support/Path.h"
105#include "llvm/Support/SHA1.h"
106#include "llvm/Support/TimeProfiler.h"
107#include "llvm/Support/VersionTuple.h"
108#include "llvm/Support/raw_ostream.h"
123using namespace clang;
126template <
typename T,
typename Allocator>
127static StringRef
bytes(
const std::vector<T, Allocator> &
v) {
128 if (
v.empty())
return StringRef();
129 return StringRef(
reinterpret_cast<const char*
>(&
v[0]),
130 sizeof(
T) *
v.size());
135 return StringRef(
reinterpret_cast<const char*
>(
v.data()),
136 sizeof(
T) *
v.size());
139static std::string
bytes(
const std::vector<bool> &
V) {
141 Str.reserve(
V.size() / 8);
142 for (
unsigned I = 0, E =
V.size(); I < E;) {
144 for (
unsigned Bit = 0; Bit < 8 && I < E; ++Bit, ++I)
157#define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
158 case Type::CLASS_ID: return TYPE_##CODE_ID;
159#include "clang/Serialization/TypeBitCodes.def"
161 llvm_unreachable(
"shouldn't be serializing a builtin type this way");
163 llvm_unreachable(
"bad type kind");
168std::optional<std::set<const FileEntry *>>
178 std::set<const FileEntry *> ModuleMaps;
179 std::set<const Module *> ProcessedModules;
180 auto CollectModuleMapsForHierarchy = [&](
const Module *M) {
181 M = M->getTopLevelModule();
183 if (!ProcessedModules.insert(M).second)
186 std::queue<const Module *> Q;
189 const Module *Mod = Q.front();
195 ModuleMaps.insert(*FE);
200 ModuleMaps.insert(*FE);
209 CollectModuleMapsForHierarchy(RootModule);
211 std::queue<const Module *> Q;
214 const Module *CurrentModule = Q.front();
218 CollectModuleMapsForHierarchy(ImportedModule);
220 CollectModuleMapsForHierarchy(UndeclaredModule);
234 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
248 if (
const Module *M = KH.getModule())
249 CollectModuleMapsForHierarchy(M);
280 : Writer(Writer), BasicWriter(Writer,
Record) {}
283 if (
T.hasLocalNonFastQualifiers()) {
290 const Type *typePtr =
T.getTypePtr();
313#define ABSTRACT_TYPELOC(CLASS, PARENT)
314#define TYPELOC(CLASS, PARENT) \
315 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
316#include "clang/AST/TypeLocNodes.def"
384 VisitArrayTypeLoc(TL);
388 VisitArrayTypeLoc(TL);
392 VisitArrayTypeLoc(TL);
395void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
397 VisitArrayTypeLoc(TL);
400void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
404 addSourceLocation(
range.getBegin());
405 addSourceLocation(
range.getEnd());
409void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
418void TypeLocWriter::VisitDependentVectorTypeLoc(
430 addSourceLocation(
range.getBegin());
431 addSourceLocation(
range.getEnd());
436void TypeLocWriter::VisitDependentSizedMatrixTypeLoc(
440 addSourceLocation(
range.getBegin());
441 addSourceLocation(
range.getEnd());
452 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i)
457 VisitFunctionTypeLoc(TL);
461 VisitFunctionTypeLoc(TL);
526void TypeLocWriter::VisitAutoTypeLoc(
AutoTypeLoc TL) {
531 Record.AddConceptReference(CR);
537void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
546void TypeLocWriter::VisitEnumTypeLoc(
EnumTypeLoc TL) {
566void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
571void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
576void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
582 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
611void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
619 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I)
655void TypeLocWriter::VisitPipeTypeLoc(
PipeTypeLoc TL) {
662void TypeLocWriter::VisitDependentBitIntTypeLoc(
667void ASTWriter::WriteTypeAbbrevs() {
668 using namespace llvm;
670 std::shared_ptr<BitCodeAbbrev> Abv;
673 Abv = std::make_shared<BitCodeAbbrev>();
675 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
676 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3));
677 TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv));
685 llvm::BitstreamWriter &Stream,
689 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID,
Record);
692 if (!Name || Name[0] == 0)
696 Record.push_back(*Name++);
697 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
Record);
701 llvm::BitstreamWriter &Stream,
706 Record.push_back(*Name++);
707 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME,
Record);
712#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
844void ASTWriter::WriteBlockInfoBlock() {
846 Stream.EnterBlockInfoBlock();
848#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
849#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
852 BLOCK(CONTROL_BLOCK);
862 BLOCK(OPTIONS_BLOCK);
869 BLOCK(INPUT_FILES_BLOCK);
931 BLOCK(SOURCE_MANAGER_BLOCK);
939 BLOCK(PREPROCESSOR_BLOCK);
947 BLOCK(SUBMODULE_BLOCK);
969 BLOCK(COMMENTS_BLOCK);
973 BLOCK(DECLTYPES_BLOCK);
977 RECORD(TYPE_BLOCK_POINTER);
978 RECORD(TYPE_LVALUE_REFERENCE);
979 RECORD(TYPE_RVALUE_REFERENCE);
980 RECORD(TYPE_MEMBER_POINTER);
981 RECORD(TYPE_CONSTANT_ARRAY);
982 RECORD(TYPE_INCOMPLETE_ARRAY);
983 RECORD(TYPE_VARIABLE_ARRAY);
986 RECORD(TYPE_FUNCTION_NO_PROTO);
987 RECORD(TYPE_FUNCTION_PROTO);
993 RECORD(TYPE_OBJC_INTERFACE);
994 RECORD(TYPE_OBJC_OBJECT_POINTER);
997 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
998 RECORD(TYPE_UNRESOLVED_USING);
999 RECORD(TYPE_INJECTED_CLASS_NAME);
1000 RECORD(TYPE_OBJC_OBJECT);
1001 RECORD(TYPE_TEMPLATE_TYPE_PARM);
1002 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
1003 RECORD(TYPE_DEPENDENT_NAME);
1004 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
1005 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
1007 RECORD(TYPE_MACRO_QUALIFIED);
1008 RECORD(TYPE_PACK_EXPANSION);
1010 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
1012 RECORD(TYPE_UNARY_TRANSFORM);
1016 RECORD(TYPE_OBJC_TYPE_PARAM);
1093 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
1099 BLOCK(EXTENSION_BLOCK);
1102 BLOCK(UNHASHED_CONTROL_BLOCK);
1121 return Changed | llvm::sys::path::remove_dots(Path);
1136 assert(
Filename &&
"No file name to adjust?");
1138 if (BaseDir.empty())
1143 for (;
Filename[Pos] && Pos < BaseDir.size(); ++Pos)
1153 if (!llvm::sys::path::is_separator(
Filename[Pos])) {
1154 if (!llvm::sys::path::is_separator(BaseDir.back()))
1171std::pair<ASTFileSignature, ASTFileSignature>
1172ASTWriter::createSignature()
const {
1173 StringRef AllBytes(Buffer.data(), Buffer.size());
1176 Hasher.update(AllBytes.slice(ASTBlockRange.first, ASTBlockRange.second));
1181 Hasher.update(AllBytes.slice(0, UnhashedControlBlockRange.first));
1184 AllBytes.slice(UnhashedControlBlockRange.second, ASTBlockRange.first));
1186 Hasher.update(AllBytes.slice(ASTBlockRange.second, StringRef::npos));
1189 return std::make_pair(ASTBlockHash, Signature);
1194 Hasher.update(StringRef(Buffer.data(), Buffer.size()));
1196 assert(WritingModule);
1201 for (
auto [ExportImported, _] : WritingModule->
Exports)
1202 Hasher.update(ExportImported->Signature);
1226 for (
Module *M : TouchedTopLevelModules)
1227 Hasher.update(M->Signature);
1234 for (uint8_t Byte : S) {
1235 Stream.BackpatchByte(BitNo, Byte);
1247 if (!WritingModule ||
1254 std::tie(ASTBlockHash, Signature) = createSignature();
1262void ASTWriter::writeUnhashedControlBlock(
Preprocessor &PP,
1264 using namespace llvm;
1267 Stream.FlushToWord();
1268 UnhashedControlBlockRange.first = Stream.GetCurrentBitNo() >> 3;
1291 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1293 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1294 unsigned ASTBlockHashAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1297 Stream.EmitRecordWithBlob(ASTBlockHashAbbrev,
Record, Blob);
1298 ASTBlockHashOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1302 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1303 Abbrev->Add(BitCodeAbbrevOp(
SIGNATURE));
1304 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1305 unsigned SignatureAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1308 Stream.EmitRecordWithBlob(SignatureAbbrev,
Record, Blob);
1309 SignatureOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1318 if (!HSOpts.ModulesSkipDiagnosticOptions) {
1319#define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1320#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1321 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1322#include "clang/Basic/DiagnosticOptions.def"
1324 for (
unsigned I = 0, N = DiagOpts.
Warnings.size(); I != N; ++I)
1327 for (
unsigned I = 0, N = DiagOpts.
Remarks.size(); I != N; ++I)
1336 if (!HSOpts.ModulesSkipHeaderSearchPaths) {
1338 Record.push_back(HSOpts.UserEntries.size());
1339 for (
unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
1342 Record.push_back(
static_cast<unsigned>(Entry.
Group));
1348 Record.push_back(HSOpts.SystemHeaderPrefixes.size());
1349 for (
unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
1351 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
1355 Record.push_back(HSOpts.VFSOverlayFiles.size());
1356 for (StringRef VFSOverlayFile : HSOpts.VFSOverlayFiles)
1362 if (!HSOpts.ModulesSkipPragmaDiagnosticMappings)
1363 WritePragmaDiagnosticMappings(Diags, WritingModule);
1368 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1370 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1371 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1372 unsigned HSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1374 HSEntryUsage.size()};
1375 Stream.EmitRecordWithBlob(HSUsageAbbrevCode,
Record,
bytes(HSEntryUsage));
1381 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1382 Abbrev->Add(BitCodeAbbrevOp(
VFS_USAGE));
1383 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1384 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1385 unsigned VFSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1387 Stream.EmitRecordWithBlob(VFSUsageAbbrevCode,
Record,
bytes(VFSUsage));
1392 UnhashedControlBlockRange.second = Stream.GetCurrentBitNo() >> 3;
1397 StringRef isysroot) {
1398 using namespace llvm;
1404 auto MetadataAbbrev = std::make_shared<BitCodeAbbrev>();
1405 MetadataAbbrev->Add(BitCodeAbbrevOp(
METADATA));
1406 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1407 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1408 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1409 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1410 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1412 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1413 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1414 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1415 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1416 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));
1417 assert((!WritingModule || isysroot.empty()) &&
1418 "writing module as a relocatable PCH?");
1423 CLANG_VERSION_MAJOR,
1424 CLANG_VERSION_MINOR,
1428 ASTHasCompilerErrors};
1429 Stream.EmitRecordWithBlob(MetadataAbbrevCode,
Record,
1433 if (WritingModule) {
1435 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1437 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1438 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1440 Stream.EmitRecordWithBlob(AbbrevCode,
Record, WritingModule->
Name);
1443 if (WritingModule && WritingModule->
Directory) {
1450 BaseDir.assign(CWD->getName());
1465 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1467 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1468 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1471 Stream.EmitRecordWithBlob(AbbrevCode,
Record, BaseDir);
1475 BaseDirectory.assign(BaseDir.begin(), BaseDir.end());
1476 }
else if (!isysroot.empty()) {
1478 BaseDirectory = std::string(isysroot);
1487 ? Map.getModuleMapFileForUniquing(WritingModule)
1488 ->getNameAsRequested()
1493 if (
auto *AdditionalModMaps =
1494 Map.getAdditionalModuleMapFiles(WritingModule)) {
1495 Record.push_back(AdditionalModMaps->size());
1497 AdditionalModMaps->end());
1517 if (!M.isDirectlyImported())
1520 Record.push_back((
unsigned)M.Kind);
1521 Record.push_back(M.StandardCXXModule);
1526 if (!M.StandardCXXModule) {
1529 Record.push_back(M.Signature ? 0 : M.File.getSize());
1531 llvm::append_range(
Record, M.Signature);
1536 if (!M.StandardCXXModule)
1548#define LANGOPT(Name, Bits, Default, Description) \
1549 Record.push_back(LangOpts.Name);
1550#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1551 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1552#include "clang/Basic/LangOptions.def"
1553#define SANITIZER(NAME, ID) \
1554 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID));
1555#include "clang/Basic/Sanitizers.def"
1595 for (
unsigned I = 0, N = TargetOpts.
Features.size(); I != N; ++I) {
1636 bool WriteMacros = !SkipMacros;
1637 Record.push_back(WriteMacros);
1641 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
1649 for (
unsigned I = 0, N = PPOpts.
Includes.size(); I != N; ++I)
1654 for (
unsigned I = 0, N = PPOpts.
MacroIncludes.size(); I != N; ++I)
1669 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID())) {
1670 auto FileAbbrev = std::make_shared<BitCodeAbbrev>();
1672 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1673 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1674 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));
1686 WriteInputFiles(Context.SourceMgr,
1694struct InputFileEntry {
1698 bool BufferOverridden;
1701 uint32_t ContentHash[2];
1713 assert(IncludeFID.
isValid() &&
"IncludeLoc in invalid file");
1714 if (!IsSLocAffecting[IncludeFID.ID])
1722 using namespace llvm;
1727 auto IFAbbrev = std::make_shared<BitCodeAbbrev>();
1729 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1730 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12));
1731 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
1732 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1733 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1734 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1735 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1736 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
1737 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1738 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));
1741 auto IFHAbbrev = std::make_shared<BitCodeAbbrev>();
1743 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1744 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1745 unsigned IFHAbbrevCode = Stream.EmitAbbrev(std::move(IFHAbbrev));
1747 uint64_t InputFilesOffsetBase = Stream.GetCurrentBitNo();
1750 std::vector<InputFileEntry> UserFiles;
1751 std::vector<InputFileEntry> SystemFiles;
1755 assert(&SourceMgr.
getSLocEntry(FileID::get(I)) == SLoc);
1762 if (!
Cache->OrigEntry)
1766 if (!IsSLocAffecting[I])
1769 InputFileEntry Entry(*
Cache->OrigEntry);
1770 Entry.IsSystemFile =
isSystem(
File.getFileCharacteristic());
1771 Entry.IsTransient =
Cache->IsTransient;
1772 Entry.BufferOverridden =
Cache->BufferOverridden;
1773 Entry.IsTopLevel = getAffectingIncludeLoc(SourceMgr,
File).
isInvalid();
1776 auto ContentHash = hash_code(-1);
1780 auto MemBuff =
Cache->getBufferIfLoaded();
1782 ContentHash =
hash_value(MemBuff->getBuffer());
1785 << Entry.File.getName();
1787 auto CH = llvm::APInt(64, ContentHash);
1788 Entry.ContentHash[0] =
1789 static_cast<uint32_t
>(CH.getLoBits(32).getZExtValue());
1790 Entry.ContentHash[1] =
1791 static_cast<uint32_t
>(CH.getHiBits(32).getZExtValue());
1793 if (Entry.IsSystemFile)
1794 SystemFiles.push_back(Entry);
1796 UserFiles.push_back(Entry);
1800 auto SortedFiles = llvm::concat<InputFileEntry>(std::move(UserFiles),
1801 std::move(SystemFiles));
1803 unsigned UserFilesNum = 0;
1805 std::vector<uint64_t> InputFileOffsets;
1806 for (
const auto &Entry : SortedFiles) {
1807 uint32_t &InputFileID = InputFileIDs[Entry.File];
1808 if (InputFileID != 0)
1812 InputFileOffsets.push_back(Stream.GetCurrentBitNo() - InputFilesOffsetBase);
1814 InputFileID = InputFileOffsets.size();
1816 if (!Entry.IsSystemFile)
1828 if (Name == NameAsRequested)
1831 RecordData::value_type
Record[] = {
1833 InputFileOffsets.size(),
1836 Entry.BufferOverridden,
1840 NameAsRequested.size()};
1842 Stream.EmitRecordWithBlob(IFAbbrevCode,
Record,
1843 (NameAsRequested + Name).str());
1849 Entry.ContentHash[1]};
1850 Stream.EmitRecordWithAbbrev(IFHAbbrevCode,
Record);
1857 auto OffsetsAbbrev = std::make_shared<BitCodeAbbrev>();
1859 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1860 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1862 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1863 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));
1867 InputFileOffsets.size(), UserFilesNum};
1868 Stream.EmitRecordWithBlob(OffsetsAbbrevCode,
Record,
bytes(InputFileOffsets));
1878 using namespace llvm;
1880 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1882 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1883 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1884 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1885 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1887 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1888 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1889 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24));
1890 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1891 return Stream.EmitAbbrev(std::move(Abbrev));
1897 using namespace llvm;
1899 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1901 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1902 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1903 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1904 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1905 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1906 return Stream.EmitAbbrev(std::move(Abbrev));
1913 using namespace llvm;
1915 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1919 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1920 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1921 return Stream.EmitAbbrev(std::move(Abbrev));
1927 using namespace llvm;
1929 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1931 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1932 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1933 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1934 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1935 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1936 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1937 return Stream.EmitAbbrev(std::move(Abbrev));
1942static std::pair<unsigned, unsigned>
1944 llvm::encodeULEB128(KeyLen, Out);
1945 llvm::encodeULEB128(DataLen, Out);
1946 return std::make_pair(KeyLen, DataLen);
1952 class HeaderFileInfoTrait {
1957 llvm::StringMap<unsigned> FrameworkNameOffset;
1960 HeaderFileInfoTrait(
ASTWriter &Writer) : Writer(Writer) {}
1967 using key_type_ref =
const key_type &;
1969 using UnresolvedModule =
1970 llvm::PointerIntPair<Module *, 2, ModuleMap::ModuleHeaderRole>;
1974 bool AlreadyIncluded;
1978 using data_type_ref =
const data_type &;
1987 return llvm::hash_combine(key.Size, key.ModTime);
1990 std::pair<unsigned, unsigned>
1991 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref
Data) {
1992 unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
1993 unsigned DataLen = 1 + 4 + 4;
1994 for (
auto ModInfo :
Data.KnownHeaders)
1997 if (
Data.Unresolved.getPointer())
2002 void EmitKey(raw_ostream& Out, key_type_ref key,
unsigned KeyLen) {
2003 using namespace llvm::support;
2005 endian::Writer
LE(Out, llvm::endianness::little);
2010 Out.write(key.Filename.data(), KeyLen);
2013 void EmitData(raw_ostream &Out, key_type_ref key,
2014 data_type_ref
Data,
unsigned DataLen) {
2015 using namespace llvm::support;
2017 endian::Writer
LE(Out, llvm::endianness::little);
2018 uint64_t Start = Out.tell(); (void)Start;
2020 unsigned char Flags = (
Data.AlreadyIncluded << 6)
2021 | (
Data.HFI.isImport << 5)
2023 Data.HFI.isPragmaOnce << 4)
2024 | (
Data.HFI.DirInfo << 1)
2025 |
Data.HFI.IndexHeaderMapHeader;
2026 LE.write<uint8_t>(Flags);
2028 if (!
Data.HFI.ControllingMacro)
2029 LE.write<uint32_t>(
Data.HFI.ControllingMacroID);
2033 unsigned Offset = 0;
2034 if (!
Data.HFI.Framework.empty()) {
2036 llvm::StringMap<unsigned>::iterator Pos
2037 = FrameworkNameOffset.find(
Data.HFI.Framework);
2038 if (Pos == FrameworkNameOffset.end()) {
2039 Offset = FrameworkStringData.size() + 1;
2040 FrameworkStringData.append(
Data.HFI.Framework);
2041 FrameworkStringData.push_back(0);
2043 FrameworkNameOffset[
Data.HFI.Framework] = Offset;
2045 Offset = Pos->second;
2047 LE.write<uint32_t>(Offset);
2051 uint32_t
Value = (ModID << 3) | (
unsigned)Role;
2052 assert((
Value >> 3) == ModID &&
"overflow in header module info");
2057 for (
auto ModInfo :
Data.KnownHeaders)
2058 EmitModule(ModInfo.getModule(), ModInfo.getRole());
2059 if (
Data.Unresolved.getPointer())
2060 EmitModule(
Data.Unresolved.getPointer(),
Data.Unresolved.getInt());
2062 assert(Out.tell() - Start == DataLen &&
"Wrong data length");
2065 const char *strings_begin()
const {
return FrameworkStringData.begin(); }
2066 const char *strings_end()
const {
return FrameworkStringData.end(); }
2074void ASTWriter::WriteHeaderSearch(
const HeaderSearch &HS) {
2075 HeaderFileInfoTrait GeneratorTrait(*
this);
2076 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait>
Generator;
2078 unsigned NumHeaderSearchEntries = 0;
2085 if (WritingModule) {
2087 while (!Worklist.empty()) {
2088 Module *M = Worklist.pop_back_val();
2105 if (!
U.Size || (!
U.ModTime && IncludeTimestamps)) {
2106 PP->
Diag(
U.FileNameLoc, diag::err_module_no_size_mtime_for_header)
2114 llvm::sys::path::append(
Filename,
U.FileName);
2117 StringRef FilenameDup = strdup(
Filename.c_str());
2118 SavedStrings.push_back(FilenameDup.data());
2120 HeaderFileInfoTrait::key_type Key = {
2121 FilenameDup, *
U.Size, IncludeTimestamps ? *
U.ModTime : 0};
2122 HeaderFileInfoTrait::data_type
Data = {
2127 ++NumHeaderSearchEntries;
2130 Worklist.append(SubmodulesRange.begin(), SubmodulesRange.end());
2140 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
2159 Filename = StringRef(strdup(FilenameTmp.c_str()));
2160 SavedStrings.push_back(
Filename.data());
2165 HeaderFileInfoTrait::key_type Key = {
2168 HeaderFileInfoTrait::data_type
Data = {
2172 ++NumHeaderSearchEntries;
2177 uint32_t BucketOffset;
2179 using namespace llvm::support;
2181 llvm::raw_svector_ostream Out(TableData);
2183 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
2184 BucketOffset =
Generator.Emit(Out, GeneratorTrait);
2188 using namespace llvm;
2190 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2192 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2193 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2194 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2195 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2196 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2200 NumHeaderSearchEntries, TableData.size()};
2201 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
2202 Stream.EmitRecordWithBlob(TableAbbrev,
Record, TableData);
2205 for (
unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
2206 free(
const_cast<char *
>(SavedStrings[I]));
2209static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
2210 unsigned SLocBufferBlobCompressedAbbrv,
2211 unsigned SLocBufferBlobAbbrv) {
2212 using RecordDataType = ASTWriter::RecordData::value_type;
2217 if (llvm::compression::zstd::isAvailable()) {
2218 llvm::compression::zstd::compress(
2219 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer, 9);
2221 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2222 llvm::toStringRef(CompressedBuffer));
2225 if (llvm::compression::zlib::isAvailable()) {
2226 llvm::compression::zlib::compress(
2227 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer);
2229 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2230 llvm::toStringRef(CompressedBuffer));
2235 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv,
Record, Blob);
2246void ASTWriter::WriteSourceManagerBlock(
SourceManager &SourceMgr,
2252 const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo();
2258 unsigned SLocBufferBlobCompressedAbbrv =
2264 std::vector<uint32_t> SLocEntryOffsets;
2265 uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
2271 FileID FID = FileID::get(I);
2275 uint64_t Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;
2276 assert((Offset >> 32) == 0 &&
"SLocEntry offset too large");
2282 if (
Cache->OrigEntry) {
2295 if (!IsSLocAffecting[I])
2297 SLocEntryOffsets.push_back(Offset);
2301 Record.push_back(
File.getFileCharacteristic());
2304 bool EmitBlob =
false;
2307 "Writing to AST an overridden file is not supported");
2310 assert(InputFileIDs[*Content->
OrigEntry] != 0 &&
"Missed file entry");
2313 Record.push_back(getAdjustedNumCreatedFIDs(FID));
2315 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
2316 if (FDI != FileDeclIDs.end()) {
2317 Record.push_back(FDI->second->FirstDeclIndex);
2318 Record.push_back(FDI->second->DeclIDs.size());
2324 Stream.EmitRecordWithAbbrev(SLocFileAbbrv,
Record);
2335 std::optional<llvm::MemoryBufferRef> Buffer =
2337 StringRef Name = Buffer ? Buffer->getBufferIdentifier() :
"";
2338 Stream.EmitRecordWithBlob(SLocBufferAbbrv,
Record,
2339 StringRef(Name.data(), Name.size() + 1));
2346 std::optional<llvm::MemoryBufferRef> Buffer =
2349 Buffer = llvm::MemoryBufferRef(
"<<<INVALID BUFFER>>>",
"");
2350 StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
2351 emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
2352 SLocBufferBlobAbbrv);
2357 SLocEntryOffsets.push_back(Offset);
2373 Record.push_back(getAdjustedOffset(NextOffset - SLoc->
getOffset()) - 1);
2374 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv,
Record);
2380 if (SLocEntryOffsets.empty())
2385 using namespace llvm;
2387 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2389 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2390 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2391 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2392 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2393 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2395 RecordData::value_type
Record[] = {
2398 SLocEntryOffsetsBase - SourceManagerBlockOffset};
2399 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev,
Record,
2400 bytes(SLocEntryOffsets));
2411 llvm::DenseMap<int, int> FilenameMap;
2412 FilenameMap[-1] = -1;
2413 for (
const auto &L : LineTable) {
2416 for (
auto &LE : L.second) {
2417 if (FilenameMap.insert(std::make_pair(
LE.FilenameID,
2418 FilenameMap.size() - 1)).second)
2425 for (
const auto &L : LineTable) {
2433 Record.push_back(L.second.size());
2434 for (
const auto &LE : L.second) {
2437 Record.push_back(FilenameMap[
LE.FilenameID]);
2438 Record.push_back((
unsigned)
LE.FileKind);
2439 Record.push_back(
LE.IncludeOffset);
2454 if (MI->isBuiltinMacro())
2470void ASTWriter::WritePreprocessor(
const Preprocessor &PP,
bool IsModule) {
2471 uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo();
2475 WritePreprocessorDetail(*PPRec, MacroOffsetsBase);
2490 if (AssumeNonNullLoc.
isValid()) {
2504 Record.push_back(SkipInfo->FoundNonSkipPortion);
2505 Record.push_back(SkipInfo->FoundElse);
2512 Record.push_back(Cond.WasSkipping);
2513 Record.push_back(Cond.FoundNonSkip);
2514 Record.push_back(Cond.FoundElse);
2538 if (
Id.second->hadMacroDefinition() &&
2539 (!
Id.second->isFromAST() ||
2540 Id.second->hasChangedSinceDeserialization()))
2541 MacroIdentifiers.push_back(
Id.second);
2544 llvm::sort(MacroIdentifiers, llvm::deref<std::less<>>());
2550 uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2551 assert((StartOffset >> 32) == 0 &&
"Macro identifiers offset too large");
2554 bool EmittedModuleMacros =
false;
2571 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2573 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2574 Record.push_back(VisMD->isPublic());
2576 ModuleMacroRecord.push_back(getSubmoduleID(WritingModule));
2579 ModuleMacroRecord.clear();
2580 EmittedModuleMacros =
true;
2590 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2592 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2593 Record.push_back(VisMD->isPublic());
2600 llvm::DenseMap<ModuleMacro *, unsigned> Visits;
2601 while (!Worklist.empty()) {
2602 auto *
Macro = Worklist.pop_back_val();
2605 ModuleMacroRecord.push_back(getSubmoduleID(
Macro->getOwningModule()));
2607 for (
auto *M :
Macro->overrides())
2608 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));
2611 ModuleMacroRecord.clear();
2614 for (
auto *M :
Macro->overrides())
2615 if (++Visits[M] == M->getNumOverridingMacros())
2616 Worklist.push_back(M);
2618 EmittedModuleMacros =
true;
2621 if (
Record.empty() && !EmittedModuleMacros)
2624 IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2635 std::vector<uint32_t> MacroOffsets;
2637 for (
unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2642 if (ID < FirstMacroID) {
2643 assert(0 &&
"Loaded MacroInfo entered MacroInfosToEmit ?");
2648 unsigned Index =
ID - FirstMacroID;
2649 if (Index >= MacroOffsets.size())
2650 MacroOffsets.resize(Index + 1);
2652 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2653 assert((Offset >> 32) == 0 &&
"Macro offset too large");
2654 MacroOffsets[Index] = Offset;
2681 Stream.EmitRecord(Code,
Record);
2685 for (
unsigned TokNo = 0, e = MI->
getNumTokens(); TokNo != e; ++TokNo) {
2700 using namespace llvm;
2702 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2704 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2705 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2706 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2707 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2709 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2713 MacroOffsetsBase - ASTBlockStartOffset};
2714 Stream.EmitRecordWithBlob(MacroOffsetAbbrev,
Record,
bytes(MacroOffsets));
2719 uint64_t MacroOffsetsBase) {
2729 unsigned NumPreprocessingRecords = 0;
2730 using namespace llvm;
2733 unsigned InclusionAbbrev = 0;
2735 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2737 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2738 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2739 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
2740 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2741 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2742 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2745 unsigned FirstPreprocessorEntityID
2746 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2748 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
2753 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
2756 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2757 assert((Offset >> 32) == 0 &&
"Preprocessed entity offset too large");
2758 SourceRange R = getAdjustedRange((*E)->getSourceRange());
2759 PreprocessedEntityOffsets.emplace_back(
2763 if (
auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) {
2765 MacroDefinitions[MD] = NextPreprocessorEntityID;
2772 if (
auto *ME = dyn_cast<MacroExpansion>(*E)) {
2773 Record.push_back(ME->isBuiltinMacro());
2774 if (ME->isBuiltinMacro())
2777 Record.push_back(MacroDefinitions[ME->getDefinition()]);
2782 if (
auto *ID = dyn_cast<InclusionDirective>(*E)) {
2784 Record.push_back(
ID->getFileName().size());
2785 Record.push_back(
ID->wasInQuotes());
2786 Record.push_back(
static_cast<unsigned>(
ID->getKind()));
2787 Record.push_back(
ID->importedModule());
2789 Buffer +=
ID->getFileName();
2793 Buffer +=
ID->getFile()->getName();
2794 Stream.EmitRecordWithBlob(InclusionAbbrev,
Record, Buffer);
2798 llvm_unreachable(
"Unhandled PreprocessedEntity in ASTWriter");
2803 if (NumPreprocessingRecords > 0) {
2804 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2807 using namespace llvm;
2809 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2811 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2812 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2813 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2816 FirstPreprocessorEntityID -
2818 Stream.EmitRecordWithBlob(PPEOffsetAbbrev,
Record,
2819 bytes(PreprocessedEntityOffsets));
2824 if (SkippedRanges.size() > 0) {
2825 std::vector<PPSkippedRange> SerializedSkippedRanges;
2826 SerializedSkippedRanges.reserve(SkippedRanges.size());
2827 for (
auto const&
Range : SkippedRanges)
2828 SerializedSkippedRanges.emplace_back(
2832 using namespace llvm;
2833 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2835 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2836 unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2840 Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev,
Record,
2841 bytes(SerializedSkippedRanges));
2849 auto Known = SubmoduleIDs.find(Mod);
2850 if (Known != SubmoduleIDs.end())
2851 return Known->second;
2854 if (Top != WritingModule &&
2856 !Top->fullModuleNameIs(StringRef(
getLangOpts().CurrentModule))))
2859 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2862unsigned ASTWriter::getSubmoduleID(
Module *Mod) {
2875 unsigned ChildModules = 0;
2879 return ChildModules + 1;
2882void ASTWriter::WriteSubmodules(
Module *WritingModule) {
2887 using namespace llvm;
2889 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2891 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2892 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2893 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));
2894 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
2895 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2896 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2897 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2898 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2899 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2900 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2901 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2902 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2903 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2904 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2905 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2906 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2908 Abbrev = std::make_shared<BitCodeAbbrev>();
2910 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2911 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2913 Abbrev = std::make_shared<BitCodeAbbrev>();
2915 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2916 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2918 Abbrev = std::make_shared<BitCodeAbbrev>();
2920 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2921 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2923 Abbrev = std::make_shared<BitCodeAbbrev>();
2925 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2926 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2928 Abbrev = std::make_shared<BitCodeAbbrev>();
2930 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2931 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2932 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2934 Abbrev = std::make_shared<BitCodeAbbrev>();
2936 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2937 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2939 Abbrev = std::make_shared<BitCodeAbbrev>();
2941 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2942 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2944 Abbrev = std::make_shared<BitCodeAbbrev>();
2946 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2947 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2949 Abbrev = std::make_shared<BitCodeAbbrev>();
2951 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2952 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2954 Abbrev = std::make_shared<BitCodeAbbrev>();
2956 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2957 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2958 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2960 Abbrev = std::make_shared<BitCodeAbbrev>();
2962 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2963 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2965 Abbrev = std::make_shared<BitCodeAbbrev>();
2967 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2968 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2969 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2971 Abbrev = std::make_shared<BitCodeAbbrev>();
2973 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2974 unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2977 RecordData::value_type
Record[] = {
2983 std::queue<Module *> Q;
2984 Q.push(WritingModule);
2985 while (!Q.empty()) {
2988 unsigned ID = getSubmoduleID(Mod);
2992 assert(SubmoduleIDs[Mod->
Parent] &&
"Submodule parent not written?");
2993 ParentID = SubmoduleIDs[Mod->
Parent];
3004 (RecordData::value_type)Mod->
Kind,
3016 Stream.EmitRecordWithBlob(DefinitionAbbrev,
Record, Mod->
Name);
3022 Stream.EmitRecordWithBlob(RequiresAbbrev,
Record, R.FeatureName);
3026 if (std::optional<Module::Header> UmbrellaHeader =
3029 Stream.EmitRecordWithBlob(UmbrellaAbbrev,
Record,
3030 UmbrellaHeader->NameAsWritten);
3031 }
else if (std::optional<Module::DirectoryName> UmbrellaDir =
3034 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev,
Record,
3035 UmbrellaDir->NameAsWritten);
3040 unsigned RecordKind;
3051 for (
auto &HL : HeaderLists) {
3052 RecordData::value_type
Record[] = {HL.RecordKind};
3053 for (
auto &H : Mod->
Headers[HL.HeaderKind])
3054 Stream.EmitRecordWithBlob(HL.Abbrev,
Record, H.NameAsWritten);
3063 Stream.EmitRecordWithBlob(TopHeaderAbbrev,
Record, HeaderName);
3071 Record.push_back(getSubmoduleID(I));
3079 Record.push_back(getSubmoduleID(I));
3086 for (
const auto &E : Mod->
Exports) {
3089 Record.push_back(getSubmoduleID(E.getPointer()));
3090 Record.push_back(E.getInt());
3105 Stream.EmitRecordWithBlob(LinkLibraryAbbrev,
Record, LL.Library);
3113 getSubmoduleID(
C.Other)};
3114 Stream.EmitRecordWithBlob(ConflictAbbrev,
Record,
C.Message);
3120 Stream.EmitRecordWithBlob(ConfigMacroAbbrev,
Record, CM);
3145 assert((NextSubmoduleID - FirstSubmoduleID ==
3147 "Wrong # of submodules; found a reference to a non-local, "
3148 "non-imported submodule?");
3153 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
3155 unsigned CurrID = 0;
3158 auto EncodeDiagStateFlags =
3159 [](
const DiagnosticsEngine::DiagState *DS) ->
unsigned {
3162 {(
unsigned)DS->IgnoreAllWarnings, (
unsigned)DS->EnableAllWarnings,
3163 (
unsigned)DS->WarningsAsErrors, (
unsigned)DS->ErrorsAsFatal,
3164 (
unsigned)DS->SuppressSystemWarnings})
3169 unsigned Flags = EncodeDiagStateFlags(
Diag.DiagStatesByLoc.FirstDiagState);
3172 auto AddDiagState = [&](
const DiagnosticsEngine::DiagState *State,
3173 bool IncludeNonPragmaStates) {
3176 assert(Flags == EncodeDiagStateFlags(State) &&
3177 "diag state flags vary in single AST file");
3181 assert(!IncludeNonPragmaStates ||
3182 State ==
Diag.DiagStatesByLoc.FirstDiagState);
3184 unsigned &DiagStateID = DiagStateIDMap[State];
3185 Record.push_back(DiagStateID);
3187 if (DiagStateID == 0) {
3188 DiagStateID = ++CurrID;
3192 auto SizeIdx =
Record.size();
3194 for (
const auto &I : *State) {
3196 if (!I.second.isPragma() && !IncludeNonPragmaStates)
3200 if (!I.second.isPragma() &&
3203 Mappings.push_back(I);
3207 llvm::sort(Mappings, [](
const auto &LHS,
const auto &RHS) {
3208 return LHS.first < RHS.first;
3211 for (
const auto &I : Mappings) {
3212 Record.push_back(I.first);
3213 Record.push_back(I.second.serialize());
3220 AddDiagState(
Diag.DiagStatesByLoc.FirstDiagState, isModule);
3223 auto NumLocationsIdx =
Record.size();
3227 unsigned NumLocations = 0;
3228 for (
auto &FileIDAndFile :
Diag.DiagStatesByLoc.Files) {
3229 if (!FileIDAndFile.first.isValid() ||
3230 !FileIDAndFile.second.HasLocalTransitions)
3236 Record.push_back(FileIDAndFile.second.StateTransitions.size());
3237 for (
auto &StatePoint : FileIDAndFile.second.StateTransitions) {
3238 Record.push_back(getAdjustedOffset(StatePoint.Offset));
3239 AddDiagState(StatePoint.State,
false);
3244 Record[NumLocationsIdx] = NumLocations;
3253 AddDiagState(
Diag.DiagStatesByLoc.CurDiagState,
false);
3266 IdxRef =
TypeIdx(NextTypeID++);
3269 assert(Idx.
getIndex() >= FirstTypeID &&
"Re-writing a type from a prior AST");
3272 uint64_t Offset = ASTTypeWriter(*this).write(
T) - DeclTypesBlockStartOffset;
3275 unsigned Index = Idx.
getIndex() - FirstTypeID;
3276 if (TypeOffsets.size() == Index)
3277 TypeOffsets.emplace_back(Offset);
3278 else if (TypeOffsets.size() < Index) {
3279 TypeOffsets.resize(Index + 1);
3280 TypeOffsets[Index].set(Offset);
3282 llvm_unreachable(
"Types emitted in wrong order");
3291 auto *ND = dyn_cast<NamedDecl>(D);
3315 uint64_t Offset = Stream.GetCurrentBitNo();
3317 for (
const auto *D : DC->
decls()) {
3326 if (GeneratingReducedBMI && !D->isFromExplicitGlobalModule() &&
3330 KindDeclPairs.push_back(D->getKind());
3331 KindDeclPairs.push_back(
GetDeclRef(D).get());
3334 ++NumLexicalDeclContexts;
3336 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev,
Record,
3337 bytes(KindDeclPairs));
3341void ASTWriter::WriteTypeDeclOffsets() {
3342 using namespace llvm;
3345 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3347 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3348 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3349 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3350 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3354 Stream.EmitRecordWithBlob(TypeOffsetAbbrev,
Record,
bytes(TypeOffsets));
3358 Abbrev = std::make_shared<BitCodeAbbrev>();
3360 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3361 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3362 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3363 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3367 Stream.EmitRecordWithBlob(DeclOffsetAbbrev,
Record,
bytes(DeclOffsets));
3371void ASTWriter::WriteFileDeclIDsMap() {
3372 using namespace llvm;
3375 SortedFileDeclIDs.reserve(FileDeclIDs.size());
3376 for (
const auto &
P : FileDeclIDs)
3377 SortedFileDeclIDs.push_back(std::make_pair(
P.first,
P.second.get()));
3378 llvm::sort(SortedFileDeclIDs, llvm::less_first());
3382 for (
auto &FileDeclEntry : SortedFileDeclIDs) {
3383 DeclIDInFileInfo &Info = *FileDeclEntry.second;
3384 Info.FirstDeclIndex = FileGroupedDeclIDs.size();
3385 llvm::stable_sort(Info.DeclIDs);
3386 for (
auto &LocDeclEntry : Info.DeclIDs)
3387 FileGroupedDeclIDs.push_back(LocDeclEntry.second.get());
3390 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3392 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3393 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3394 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
3396 FileGroupedDeclIDs.size()};
3397 Stream.EmitRecordWithBlob(AbbrevCode,
Record,
bytes(FileGroupedDeclIDs));
3400void ASTWriter::WriteComments() {
3402 auto _ = llvm::make_scope_exit([
this] { Stream.ExitBlock(); });
3413 for (
const auto &FO : Context->
Comments.OrderedComments) {
3414 for (
const auto &OC : FO.second) {
3433class ASTMethodPoolTrait {
3438 using key_type_ref = key_type;
3444 using data_type_ref =
const data_type &;
3449 explicit ASTMethodPoolTrait(
ASTWriter &Writer) : Writer(Writer) {}
3455 std::pair<unsigned, unsigned>
3456 EmitKeyDataLength(raw_ostream& Out,
Selector Sel,
3457 data_type_ref Methods) {
3459 unsigned DataLen = 4 + 2 + 2;
3462 if (ShouldWriteMethodListNode(Method))
3463 DataLen +=
sizeof(
DeclID);
3466 if (ShouldWriteMethodListNode(Method))
3467 DataLen +=
sizeof(
DeclID);
3471 void EmitKey(raw_ostream& Out,
Selector Sel,
unsigned) {
3472 using namespace llvm::support;
3474 endian::Writer
LE(Out, llvm::endianness::little);
3476 assert((Start >> 32) == 0 &&
"Selector key offset too large");
3479 LE.write<uint16_t>(N);
3482 for (
unsigned I = 0; I != N; ++I)
3487 void EmitData(raw_ostream& Out, key_type_ref,
3488 data_type_ref Methods,
unsigned DataLen) {
3489 using namespace llvm::support;
3491 endian::Writer
LE(Out, llvm::endianness::little);
3492 uint64_t Start = Out.tell(); (void)Start;
3493 LE.write<uint32_t>(Methods.ID);
3494 unsigned NumInstanceMethods = 0;
3497 if (ShouldWriteMethodListNode(Method))
3498 ++NumInstanceMethods;
3500 unsigned NumFactoryMethods = 0;
3503 if (ShouldWriteMethodListNode(Method))
3504 ++NumFactoryMethods;
3506 unsigned InstanceBits = Methods.Instance.getBits();
3507 assert(InstanceBits < 4);
3508 unsigned InstanceHasMoreThanOneDeclBit =
3509 Methods.Instance.hasMoreThanOneDecl();
3510 unsigned FullInstanceBits = (NumInstanceMethods << 3) |
3511 (InstanceHasMoreThanOneDeclBit << 2) |
3513 unsigned FactoryBits = Methods.Factory.getBits();
3514 assert(FactoryBits < 4);
3515 unsigned FactoryHasMoreThanOneDeclBit =
3516 Methods.Factory.hasMoreThanOneDecl();
3517 unsigned FullFactoryBits = (NumFactoryMethods << 3) |
3518 (FactoryHasMoreThanOneDeclBit << 2) |
3520 LE.write<uint16_t>(FullInstanceBits);
3521 LE.write<uint16_t>(FullFactoryBits);
3524 if (ShouldWriteMethodListNode(Method))
3528 if (ShouldWriteMethodListNode(Method))
3531 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
3536 return (
Node->getMethod() && !
Node->getMethod()->isFromASTFile());
3547void ASTWriter::WriteSelectors(
Sema &SemaRef) {
3548 using namespace llvm;
3553 unsigned NumTableEntries = 0;
3556 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait>
Generator;
3557 ASTMethodPoolTrait Trait(*
this);
3561 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
3562 for (
auto &SelectorAndID : SelectorIDs) {
3567 ASTMethodPoolTrait::data_type
Data = {
3573 Data.Instance = F->second.first;
3574 Data.Factory = F->second.second;
3578 if (Chain && ID < FirstSelectorID) {
3580 bool changed =
false;
3583 if (!M->getMethod()->isFromASTFile()) {
3591 if (!M->getMethod()->isFromASTFile()) {
3599 }
else if (
Data.Instance.getMethod() ||
Data.Factory.getMethod()) {
3608 uint32_t BucketOffset;
3610 using namespace llvm::support;
3612 ASTMethodPoolTrait Trait(*
this);
3613 llvm::raw_svector_ostream Out(MethodPool);
3615 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3616 BucketOffset =
Generator.Emit(Out, Trait);
3620 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3622 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3623 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3624 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3625 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3631 Stream.EmitRecordWithBlob(MethodPoolAbbrev,
Record, MethodPool);
3635 Abbrev = std::make_shared<BitCodeAbbrev>();
3637 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3638 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3639 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3640 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3644 RecordData::value_type
Record[] = {
3647 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev,
Record,
3648 bytes(SelectorOffsets));
3654void ASTWriter::WriteReferencedSelectorsPool(
Sema &SemaRef) {
3655 using namespace llvm;
3667 Selector Sel = SelectorAndLocation.first;
3669 Writer.AddSelectorRef(Sel);
3691 for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
3693 if (!Redecl->isFromASTFile()) {
3697 if (!Redecl->getDeclContext()->getRedeclContext()->Equals(
3700 return cast<NamedDecl>(Redecl);
3705 if (Redecl->getOwningModuleID() == 0)
3710 if (!
First->isFromASTFile())
3711 return cast<NamedDecl>(
First);
3721class ASTIdentifierTableTrait {
3734 bool IsInteresting =
3736 tok::NotableIdentifierKind::not_notable ||
3739 if (MacroOffset || II->
isPoisoned() || (!IsModule && IsInteresting) ||
3749 using key_type_ref = key_type;
3752 using data_type_ref = data_type;
3760 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule),
3761 NeedDecls(!IsModule || !Writer.getLangOpts().
CPlusPlus),
3762 InterestingIdentifierOffsets(InterestingIdentifierOffsets) {}
3764 bool needDecls()
const {
return NeedDecls; }
3767 return llvm::djbHash(II->
getName());
3779 std::pair<unsigned, unsigned>
3789 if (InterestingIdentifierOffsets &&
3791 InterestingIdentifierOffsets->push_back(Out.tell());
3794 unsigned DataLen = 4;
3802 DataLen += std::distance(IdResolver.
begin(II), IdResolver.
end()) *
3808 void EmitKey(raw_ostream &Out,
const IdentifierInfo *II,
unsigned KeyLen) {
3814 using namespace llvm::support;
3816 endian::Writer
LE(Out, llvm::endianness::little);
3820 LE.write<uint32_t>(
ID << 1);
3824 LE.write<uint32_t>((
ID << 1) | 0x01);
3826 assert((Bits & 0xffff) == Bits &&
"ObjCOrBuiltinID too big for ASTReader.");
3827 LE.write<uint16_t>(Bits);
3829 bool HadMacroDefinition = MacroOffset != 0;
3830 Bits = (Bits << 1) |
unsigned(HadMacroDefinition);
3832 Bits = (Bits << 1) |
unsigned(II->
isPoisoned());
3835 LE.write<uint16_t>(Bits);
3837 if (HadMacroDefinition)
3838 LE.write<uint32_t>(MacroOffset);
3848 for (
NamedDecl *D : llvm::reverse(Decls))
3865 using namespace llvm;
3872 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait>
Generator;
3873 ASTIdentifierTableTrait Trait(*
this, PP, IdResolver, IsModule,
3874 IsModule ? &InterestingIdents :
nullptr);
3883 if (Trait.isInterestingNonMacroIdentifier(
ID.second))
3884 IIs.push_back(
ID.second);
3887 llvm::sort(IIs, llvm::deref<std::less<>>());
3893 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
3894 for (
auto IdentIDPair : IdentifierIDs) {
3897 assert(II &&
"NULL identifier in identifier table");
3901 if (ID >= FirstIdentID || !Chain || !II->
isFromAST() ||
3903 (Trait.needDecls() &&
3910 uint32_t BucketOffset;
3912 using namespace llvm::support;
3916 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3917 BucketOffset =
Generator.Emit(Out, Trait);
3921 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3923 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3924 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3925 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3933 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3935 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3936 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3937 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3938 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3941 for (
unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
3942 assert(IdentifierOffsets[I] &&
"Missing identifier offset?");
3946 IdentifierOffsets.size(),
3948 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev,
Record,
3949 bytes(IdentifierOffsets));
3953 if (!InterestingIdents.empty())
3964class ASTDeclContextNameLookupTrait {
3970 using key_type_ref = key_type;
3973 using data_type = std::pair<unsigned, unsigned>;
3974 using data_type_ref =
const data_type &;
3979 explicit ASTDeclContextNameLookupTrait(
ASTWriter &Writer) : Writer(Writer) {}
3981 template<
typename Coll>
3982 data_type getData(
const Coll &Decls) {
3983 unsigned Start = DeclIDs.size();
3999 DeclIDs.push_back(Writer.
GetDeclRef(DeclForLocalLookup));
4001 return std::make_pair(Start, DeclIDs.size());
4005 unsigned Start = DeclIDs.size();
4010 return std::make_pair(Start, DeclIDs.size());
4013 static bool EqualKey(key_type_ref a, key_type_ref
b) {
4018 return Name.getHash();
4021 void EmitFileRef(raw_ostream &Out,
ModuleFile *F)
const {
4023 "have reference to loaded module file but no chain?");
4025 using namespace llvm::support;
4028 llvm::endianness::little);
4031 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
4033 data_type_ref Lookup) {
4034 unsigned KeyLen = 1;
4035 switch (Name.getKind()) {
4055 unsigned DataLen =
sizeof(
DeclID) * (Lookup.second - Lookup.first);
4061 using namespace llvm::support;
4063 endian::Writer
LE(Out, llvm::endianness::little);
4064 LE.write<uint8_t>(Name.getKind());
4065 switch (Name.getKind()) {
4078 "Invalid operator?");
4079 LE.write<uint8_t>(Name.getOperatorKind());
4088 llvm_unreachable(
"Invalid name kind?");
4091 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
4093 using namespace llvm::support;
4095 endian::Writer
LE(Out, llvm::endianness::little);
4096 uint64_t Start = Out.tell(); (void)Start;
4097 for (
unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
4099 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
4107 return Result.hasExternalDecls() &&
4108 DC->hasNeedToReconcileExternalVisibleStorage();
4111bool ASTWriter::isLookupResultEntirelyExternalOrUnreachable(
4113 for (
auto *D :
Result.getLookupResult()) {
4115 if (LocalD->isFromASTFile())
4130ASTWriter::GenerateNameLookupTable(
const DeclContext *ConstDC,
4132 assert(!ConstDC->hasLazyLocalLexicalLookups() &&
4133 !ConstDC->hasLazyExternalLexicalLookups() &&
4134 "must call buildLookups first");
4142 ASTDeclContextNameLookupTrait>
Generator;
4143 ASTDeclContextNameLookupTrait Trait(*
this);
4155 auto &Name = Lookup.first;
4156 auto &
Result = Lookup.second;
4171 if ((GeneratingReducedBMI || isLookupResultExternal(
Result, DC)) &&
4172 isLookupResultEntirelyExternalOrUnreachable(
Result, DC))
4189 if (Lookup.second.getLookupResult().empty())
4192 switch (Lookup.first.getNameKind()) {
4194 Names.push_back(Lookup.first);
4198 assert(isa<CXXRecordDecl>(DC) &&
4199 "Cannot have a constructor name outside of a class!");
4200 ConstructorNameSet.insert(Name);
4204 assert(isa<CXXRecordDecl>(DC) &&
4205 "Cannot have a conversion function name outside of a class!");
4206 ConversionNameSet.insert(Name);
4214 if (
auto *D = dyn_cast<CXXRecordDecl>(DC)) {
4228 if (ConstructorNameSet.erase(ImplicitCtorName))
4229 Names.push_back(ImplicitCtorName);
4234 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty())
4235 for (
Decl *ChildD : cast<CXXRecordDecl>(DC)->decls())
4236 if (
auto *ChildND = dyn_cast<NamedDecl>(ChildD)) {
4237 auto Name = ChildND->getDeclName();
4238 switch (Name.getNameKind()) {
4243 if (ConstructorNameSet.erase(Name))
4244 Names.push_back(Name);
4248 if (ConversionNameSet.erase(Name))
4249 Names.push_back(Name);
4253 if (ConstructorNameSet.empty() && ConversionNameSet.empty())
4257 assert(ConstructorNameSet.empty() &&
"Failed to find all of the visible "
4258 "constructors by walking all the "
4259 "lexical members of the context.");
4260 assert(ConversionNameSet.empty() &&
"Failed to find all of the visible "
4261 "conversion functions by walking all "
4262 "the lexical members of the context.");
4269 for (
auto &Name : Names)
4281 for (
auto &Name : Names) {
4284 switch (Name.getNameKind()) {
4302 if (!ConstructorDecls.empty())
4303 Generator.insert(ConstructorDecls.front()->getDeclName(),
4304 Trait.getData(ConstructorDecls), Trait);
4305 if (!ConversionDecls.empty())
4306 Generator.insert(ConversionDecls.front()->getDeclName(),
4307 Trait.getData(ConversionDecls), Trait);
4312 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table :
nullptr);
4325 if (isa<NamespaceDecl>(DC) && Chain &&
4328 for (
auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;
4329 Prev = Prev->getPreviousDecl())
4330 if (!Prev->isFromASTFile())
4343 LookupResults.reserve(Map->size());
4344 for (
auto &Entry : *Map)
4345 LookupResults.push_back(
4346 std::make_pair(Entry.first, Entry.second.getLookupResult()));
4349 llvm::sort(LookupResults, llvm::less_first());
4350 for (
auto &NameAndResult : LookupResults) {
4358 assert(
Result.empty() &&
"Cannot have a constructor or conversion "
4359 "function name in a namespace!");
4364 if (ND->isFromASTFile())
4372 if (GeneratingReducedBMI && !ND->isFromExplicitGlobalModule() &&
4400 uint64_t Offset = Stream.GetCurrentBitNo();
4402 if (!Map || Map->empty())
4407 GenerateNameLookupTable(DC, LookupTable);
4411 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev,
Record,
4413 ++NumVisibleDeclContexts;
4423void ASTWriter::WriteDeclContextVisibleUpdate(
const DeclContext *DC) {
4425 if (!Map || Map->empty())
4430 GenerateNameLookupTable(DC, LookupTable);
4434 if (isa<NamespaceDecl>(DC))
4440 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev,
Record, LookupTable);
4450void ASTWriter::WriteOpenCLExtensions(
Sema &SemaRef) {
4456 for (
const auto &I:Opts.OptMap) {
4458 auto V = I.getValue();
4459 Record.push_back(
V.Supported ? 1 : 0);
4460 Record.push_back(
V.Enabled ? 1 : 0);
4461 Record.push_back(
V.WithPragma ? 1 : 0);
4468void ASTWriter::WriteCUDAPragmas(
Sema &SemaRef) {
4469 if (SemaRef.
CUDA().ForceHostDeviceDepth > 0) {
4470 RecordData::value_type
Record[] = {SemaRef.
CUDA().ForceHostDeviceDepth};
4475void ASTWriter::WriteObjCCategories() {
4479 for (
unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
4481 unsigned StartIndex = Categories.size();
4486 Categories.push_back(0);
4490 Cat =
Class->known_categories_begin(),
4491 CatEnd =
Class->known_categories_end();
4492 Cat != CatEnd; ++Cat, ++Size) {
4498 Categories[StartIndex] =
Size;
4502 CategoriesMap.push_back(CatInfo);
4507 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
4510 using namespace llvm;
4512 auto Abbrev = std::make_shared<BitCodeAbbrev>();
4514 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
4515 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4516 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
4519 Stream.EmitRecordWithBlob(AbbrevID,
Record,
4520 reinterpret_cast<char *
>(CategoriesMap.data()),
4527void ASTWriter::WriteLateParsedTemplates(
Sema &SemaRef) {
4534 for (
auto &LPTMapEntry : LPTMap) {
4542 for (
const auto &Tok : LPT.
Toks) {
4550void ASTWriter::WriteOptimizePragmaOptions(
Sema &SemaRef) {
4558void ASTWriter::WriteMSStructPragmaOptions(
Sema &SemaRef) {
4566void ASTWriter::WriteMSPointersToMembersPragmaOptions(
Sema &SemaRef) {
4574void ASTWriter::WritePackPragmaOptions(
Sema &SemaRef) {
4594void ASTWriter::WriteFloatControlPragmaOptions(
Sema &SemaRef) {
4604 for (
const auto &StackEntry : SemaRef.
FpPragmaStack.Stack) {
4605 Record.push_back(StackEntry.Value.getAsOpaqueInt());
4613void ASTWriter::WriteModuleFileExtension(
Sema &SemaRef,
4619 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
4621 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4622 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4623 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4624 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4625 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4626 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv));
4632 Record.push_back(Metadata.MajorVersion);
4633 Record.push_back(Metadata.MinorVersion);
4634 Record.push_back(Metadata.BlockName.size());
4635 Record.push_back(Metadata.UserInfo.size());
4637 Buffer += Metadata.BlockName;
4638 Buffer += Metadata.UserInfo;
4639 Stream.EmitRecordWithBlob(Abbrev,
Record, Buffer);
4657 if (!A || (isa<PreferredNameAttr>(A) &&
4658 Writer->isWritingStdCXXNamedModules()))
4659 return Record.push_back(0);
4669 Record.push_back(A->getAttributeSpellingListIndexRaw());
4672#include "clang/Serialization/AttrPCHWrite.inc"
4678 for (
const auto *A : Attrs)
4692 case tok::annot_pragma_loop_hint: {
4696 Record.push_back(Info->Toks.size());
4697 for (
const auto &
T : Info->Toks)
4701 case tok::annot_pragma_pack: {
4704 Record.push_back(
static_cast<unsigned>(Info->Action));
4710 case tok::annot_pragma_openmp:
4711 case tok::annot_pragma_openmp_end:
4712 case tok::annot_pragma_unused:
4713 case tok::annot_pragma_openacc:
4714 case tok::annot_pragma_openacc_end:
4717 llvm_unreachable(
"missing serialization code for annotation token");
4728 Record.push_back(Str.size());
4733 assert(Context &&
"should have context when outputting path");
4736 StringRef PathStr(Path.data(), Path.size());
4737 if (PathStr ==
"<built-in>" || PathStr ==
"<command line>")
4744 const char *PathBegin = Path.data();
4745 const char *PathPtr =
4747 if (PathPtr != PathBegin) {
4748 Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin));
4765 Stream.EmitRecordWithBlob(Abbrev,
Record, FilePath);
4770 Record.push_back(Version.getMajor());
4771 if (std::optional<unsigned> Minor = Version.getMinor())
4772 Record.push_back(*Minor + 1);
4775 if (std::optional<unsigned> Subminor = Version.getSubminor())
4776 Record.push_back(*Subminor + 1);
4787 if (ID >= FirstIdentID)
4788 IdentifierOffsets[ID - FirstIdentID] = Offset;
4794 unsigned ID = SelectorIDs[Sel];
4795 assert(ID &&
"Unknown selector");
4798 if (ID < FirstSelectorID)
4800 SelectorOffsets[ID - FirstSelectorID] = Offset;
4806 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
4807 bool IncludeTimestamps,
bool BuildingImplicitModule,
4808 bool GeneratingReducedBMI)
4809 : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),
4810 IncludeTimestamps(IncludeTimestamps),
4811 BuildingImplicitModule(BuildingImplicitModule),
4812 GeneratingReducedBMI(GeneratingReducedBMI) {
4813 for (
const auto &Ext : Extensions) {
4814 if (
auto Writer = Ext->createExtensionWriter(*
this))
4815 ModuleFileExtensionWriters.push_back(std::move(Writer));
4822 assert(WritingAST &&
"can't determine lang opts when not writing AST");
4831 Module *WritingModule, StringRef isysroot,
4832 bool ShouldCacheASTInMemory) {
4833 llvm::TimeTraceScope scope(
"WriteAST", OutputFile);
4836 ASTHasCompilerErrors =
4840 Stream.Emit((
unsigned)
'C', 8);
4841 Stream.Emit((
unsigned)
'P', 8);
4842 Stream.Emit((
unsigned)
'C', 8);
4843 Stream.Emit((
unsigned)
'H', 8);
4845 WriteBlockInfoBlock();
4849 this->WritingModule = WritingModule;
4850 ASTFileSignature Signature = WriteASTCore(SemaRef, isysroot, WritingModule);
4853 this->WritingModule =
nullptr;
4854 this->BaseDirectory.clear();
4857 if (ShouldCacheASTInMemory) {
4860 llvm::MemoryBuffer::getMemBufferCopy(
4861 StringRef(Buffer.begin(), Buffer.size())));
4866template<
typename Vector>
4868 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true), E = Vec.end();
4874template <
typename Vector>
4877 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true), E = Vec.end();
4883void ASTWriter::computeNonAffectingInputFiles() {
4887 IsSLocAffecting.resize(N,
true);
4892 auto AffectingModuleMaps = GetAffectingModuleMaps(*PP, WritingModule);
4894 unsigned FileIDAdjustment = 0;
4895 unsigned OffsetAdjustment = 0;
4897 NonAffectingFileIDAdjustments.reserve(N);
4898 NonAffectingOffsetAdjustments.reserve(N);
4900 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
4901 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
4903 for (
unsigned I = 1; I != N; ++I) {
4905 FileID FID = FileID::get(I);
4912 if (!
Cache->OrigEntry)
4920 if (!AffectingModuleMaps)
4924 if (llvm::is_contained(*AffectingModuleMaps, *
Cache->OrigEntry))
4927 IsSLocAffecting[I] =
false;
4929 FileIDAdjustment += 1;
4935 if (!NonAffectingFileIDs.empty() &&
4936 NonAffectingFileIDs.back().ID == FID.ID - 1) {
4937 NonAffectingFileIDs.back() = FID;
4939 NonAffectingFileIDAdjustments.back() = FileIDAdjustment;
4940 NonAffectingOffsetAdjustments.back() = OffsetAdjustment;
4944 NonAffectingFileIDs.push_back(FID);
4947 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
4948 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
4957 for (StringRef Path :
4960 for (
unsigned I = 1; I != N; ++I) {
4961 if (IsSLocAffecting[I]) {
4967 if (!
Cache->OrigEntry)
4970 Cache->OrigEntry->getNameAsRequested());
4976void ASTWriter::PrepareWritingSpecialDecls(
Sema &SemaRef) {
4979 bool isModule = WritingModule !=
nullptr;
4993 RegisterPredefDecl(Context.ObjCProtocolClassDecl,
4997 RegisterPredefDecl(Context.ObjCInstanceTypeDecl,
5001 RegisterPredefDecl(Context.BuiltinMSVaListDecl,
5006 RegisterPredefDecl(Context.MakeIntegerSeqDecl,
5008 RegisterPredefDecl(Context.CFConstantStringTypeDecl,
5010 RegisterPredefDecl(Context.CFConstantStringTagDecl,
5012 RegisterPredefDecl(Context.TypePackElementDecl,
5025 if (GeneratingReducedBMI) {
5043 if (GeneratingReducedBMI)
5066 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I)
5077 "There are local ones at end of translation unit!");
5090 for (
const auto &I : SemaRef.KnownNamespaces)
5097 for (
const auto &I : Undefined)
5103 for (
const auto &DeleteExprsInfo :
5110 for (
const auto *I : DeclsToEmitEvenIfUnreferenced)
5112 DeclsToEmitEvenIfUnreferenced.clear();
5124 llvm::sort(IIs, llvm::deref<std::less<>>());
5131 for (
auto *D : SemaRef.DeclsToCheckForDeferredDiags)
5135void ASTWriter::WriteSpecialDeclRecords(
Sema &SemaRef) {
5138 bool isModule = WritingModule !=
nullptr;
5141 if (!EagerlyDeserializedDecls.empty())
5144 if (!ModularCodegenDecls.empty())
5150 TentativeDefinitions);
5151 if (!TentativeDefinitions.empty())
5158 UnusedFileScopedDecls);
5159 if (!UnusedFileScopedDecls.empty())
5165 if (!ExtVectorDecls.empty())
5171 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I) {
5187 if (!UnusedLocalTypedefNameCandidates.empty())
5189 UnusedLocalTypedefNameCandidates);
5200 if (!PendingInstantiations.empty())
5206 auto AddEmittedDeclRefOrZero = [
this, &SemaDeclRefs](
Decl *D) {
5208 SemaDeclRefs.push_back(0);
5217 if (!SemaDeclRefs.empty())
5222 for (
auto *D : SemaRef.DeclsToCheckForDeferredDiags)
5225 if (!DeclsToCheckForDeferredDiags.empty())
5227 DeclsToCheckForDeferredDiags);
5233 AddDeclRef(CudaCallDecl, CUDASpecialDeclRefs);
5241 DelegatingCtorDecls);
5242 if (!DelegatingCtorDecls.empty())
5247 for (
const auto &I : SemaRef.KnownNamespaces) {
5251 if (!KnownNamespaces.empty())
5258 for (
const auto &I : Undefined) {
5265 if (!UndefinedButUsed.empty())
5272 for (
const auto &DeleteExprsInfo :
5277 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze);
5278 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());
5279 for (
const auto &DeleteLoc : DeleteExprsInfo.second) {
5281 DeleteExprsToAnalyze.push_back(DeleteLoc.second);
5285 if (!DeleteExprsToAnalyze.empty())
5291 using namespace llvm;
5293 bool isModule = WritingModule !=
nullptr;
5304 computeNonAffectingInputFiles();
5306 writeUnhashedControlBlock(PP, Context);
5312 for (
const auto &WeakUndeclaredIdentifierList :
5314 const IdentifierInfo *
const II = WeakUndeclaredIdentifierList.first;
5315 for (
const auto &WI : WeakUndeclaredIdentifierList.second) {
5322 PrepareWritingSpecialDecls(SemaRef);
5325 WriteControlBlock(PP, Context, isysroot);
5328 Stream.FlushToWord();
5329 ASTBlockRange.first = Stream.GetCurrentBitNo() >> 3;
5331 ASTBlockStartOffset = Stream.GetCurrentBitNo();
5348 for (
auto &SelectorAndID : SelectorIDs)
5349 AllSelectors.push_back(SelectorAndID.first);
5350 for (
auto &
Selector : AllSelectors)
5359 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
5360 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
5361 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
5384 auto Abbrev = std::make_shared<BitCodeAbbrev>();
5386 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
5387 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
5390 llvm::raw_svector_ostream Out(Buffer);
5392 using namespace llvm::support;
5394 endian::Writer
LE(Out, llvm::endianness::little);
5395 LE.write<uint8_t>(
static_cast<uint8_t
>(M.
Kind));
5397 LE.write<uint16_t>(Name.size());
5398 Out.write(Name.data(), Name.size());
5402 uint32_t
None = std::numeric_limits<uint32_t>::max();
5404 auto writeBaseIDOrNone = [&](
auto BaseID,
bool ShouldWrite) {
5405 assert(BaseID < std::numeric_limits<uint32_t>::max() &&
"base id too high");
5407 LE.write<uint32_t>(BaseID);
5409 LE.write<uint32_t>(
None);
5425 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev,
Record,
5426 Buffer.data(), Buffer.size());
5429 WriteDeclAndTypes(Context);
5431 WriteFileDeclIDsMap();
5434 WritePreprocessor(PP, isModule);
5436 WriteSelectors(SemaRef);
5437 WriteReferencedSelectorsPool(SemaRef);
5438 WriteLateParsedTemplates(SemaRef);
5439 WriteIdentifierTable(PP, SemaRef.
IdResolver, isModule);
5441 WriteOpenCLExtensions(SemaRef);
5442 WriteCUDAPragmas(SemaRef);
5446 WriteSubmodules(WritingModule);
5450 WriteSpecialDeclRecords(SemaRef);
5453 if (!WeakUndeclaredIdentifiers.empty())
5455 WeakUndeclaredIdentifiers);
5457 if (!WritingModule) {
5466 assert(SubmoduleIDs.contains(I->getImportedModule()));
5467 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
5468 I->getImportedModule()));
5471 if (!Imports.empty()) {
5472 auto Cmp = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5475 auto Eq = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5476 return A.ID == B.ID;
5480 llvm::sort(Imports, Cmp);
5481 Imports.erase(std::unique(Imports.begin(), Imports.end(),
Eq),
5485 for (
const auto &Import : Imports) {
5486 ImportedModules.push_back(
Import.ID);
5497 WriteObjCCategories();
5498 if(!WritingModule) {
5499 WriteOptimizePragmaOptions(SemaRef);
5500 WriteMSStructPragmaOptions(SemaRef);
5501 WriteMSPointersToMembersPragmaOptions(SemaRef);
5503 WritePackPragmaOptions(SemaRef);
5504 WriteFloatControlPragmaOptions(SemaRef);
5507 RecordData::value_type
Record[] = {
5508 NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts};
5511 Stream.FlushToWord();
5512 ASTBlockRange.second = Stream.GetCurrentBitNo() >> 3;
5515 for (
const auto &ExtWriter : ModuleFileExtensionWriters)
5516 WriteModuleFileExtension(SemaRef, *ExtWriter);
5518 return backpatchSignature();
5521void ASTWriter::EnteringModulePurview() {
5524 if (GeneratingReducedBMI)
5525 DeclUpdatesFromGMF.swap(DeclUpdates);
5531void ASTWriter::AddedManglingNumber(
const Decl *D,
unsigned Number) {
5537void ASTWriter::AddedStaticLocalNumbers(
const Decl *D,
unsigned Number) {
5556void ASTWriter::WriteDeclAndTypes(
ASTContext &Context) {
5561 DeclTypesBlockStartOffset = Stream.GetCurrentBitNo();
5565 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord);
5566 while (!DeclTypesToEmit.empty()) {
5567 DeclOrType DOT = DeclTypesToEmit.front();
5568 DeclTypesToEmit.pop();
5570 WriteType(DOT.getType());
5572 WriteDecl(Context, DOT.getDecl());
5574 }
while (!DeclUpdates.empty());
5576 DoneWritingDeclsAndTypes =
true;
5580 assert(DelayedNamespace.empty() || GeneratingReducedBMI);
5583 uint64_t LexicalOffset = WriteDeclContextLexicalBlock(Context, NS);
5584 uint64_t VisibleOffset = WriteDeclContextVisibleBlock(Context, NS);
5588 LexicalOffset -= DeclTypesBlockStartOffset;
5591 VisibleOffset -= DeclTypesBlockStartOffset;
5594 DelayedNamespaceRecord.push_back(LexicalOffset);
5595 DelayedNamespaceRecord.push_back(VisibleOffset);
5600 assert(DeclTypesToEmit.empty());
5601 assert(DeclUpdates.empty());
5606 WriteTypeDeclOffsets();
5607 if (!DeclUpdatesOffsetsRecord.empty())
5610 if (!DelayedNamespaceRecord.empty())
5612 DelayedNamespaceRecord);
5626 NewGlobalKindDeclPairs.push_back(D->
getKind());
5627 NewGlobalKindDeclPairs.push_back(
GetDeclRef(D).get());
5630 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
5632 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
5633 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
5636 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev,
Record,
5637 bytes(NewGlobalKindDeclPairs));
5639 Abv = std::make_shared<llvm::BitCodeAbbrev>();
5641 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
5642 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
5643 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));
5646 WriteDeclContextVisibleUpdate(TU);
5649 if (Context.ExternCContext)
5650 WriteDeclContextVisibleUpdate(Context.ExternCContext);
5653 for (
auto *DC : UpdatedDeclContexts)
5654 WriteDeclContextVisibleUpdate(DC);
5657void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
5658 if (DeclUpdates.empty())
5661 DeclUpdateMap LocalUpdates;
5662 LocalUpdates.swap(DeclUpdates);
5664 for (
auto &DeclUpdate : LocalUpdates) {
5665 const Decl *D = DeclUpdate.first;
5667 bool HasUpdatedBody =
false;
5668 bool HasAddedVarDefinition =
false;
5671 for (
auto &
Update : DeclUpdate.second) {
5677 HasUpdatedBody =
true;
5679 HasAddedVarDefinition =
true;
5687 assert(
Update.getDecl() &&
"no decl to add?");
5702 cast<ParmVarDecl>(
Update.getDecl())->getDefaultArg());
5707 cast<FieldDecl>(
Update.getDecl())->getInClassInitializer());
5711 auto *RD = cast<CXXRecordDecl>(D);
5712 UpdatedDeclContexts.insert(RD->getPrimaryContext());
5713 Record.push_back(RD->isParamDestroyedInCallee());
5714 Record.push_back(llvm::to_underlying(RD->getArgPassingRestrictions()));
5715 Record.AddCXXDefinitionData(RD);
5716 Record.AddOffset(WriteDeclContextLexicalBlock(*Context, RD));
5721 if (
auto *MSInfo = RD->getMemberSpecializationInfo()) {
5722 Record.push_back(MSInfo->getTemplateSpecializationKind());
5723 Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
5725 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
5726 Record.push_back(Spec->getTemplateSpecializationKind());
5727 Record.AddSourceLocation(Spec->getPointOfInstantiation());
5731 auto From = Spec->getInstantiatedFrom();
5732 if (
auto PartialSpec =
5735 Record.AddDeclRef(PartialSpec);
5736 Record.AddTemplateArgumentList(
5737 &Spec->getTemplateInstantiationArgs());
5742 Record.push_back(llvm::to_underlying(RD->getTagKind()));
5743 Record.AddSourceLocation(RD->getLocation());
5744 Record.AddSourceLocation(RD->getBeginLoc());
5745 Record.AddSourceRange(RD->getBraceRange());
5758 Record.AddStmt(cast<CXXDestructorDecl>(D)->getOperatorDeleteThisArg());
5764 Record.writeExceptionSpecInfo(prototype->getExceptionSpecInfo());
5782 D->
getAttr<OMPThreadPrivateDeclAttr>()->getRange());
5786 auto *A = D->
getAttr<OMPAllocateDeclAttr>();
5787 Record.push_back(A->getAllocatorType());
5788 Record.AddStmt(A->getAllocator());
5789 Record.AddStmt(A->getAlignment());
5790 Record.AddSourceRange(A->getRange());
5795 Record.push_back(D->
getAttr<OMPDeclareTargetDeclAttr>()->getMapType());
5797 D->
getAttr<OMPDeclareTargetDeclAttr>()->getRange());
5813 if (HasUpdatedBody) {
5814 const auto *Def = cast<FunctionDecl>(D);
5816 Record.push_back(Def->isInlined());
5817 Record.AddSourceLocation(Def->getInnerLocStart());
5818 Record.AddFunctionDefinition(Def);
5819 }
else if (HasAddedVarDefinition) {
5820 const auto *VD = cast<VarDecl>(D);
5822 Record.push_back(VD->isInline());
5823 Record.push_back(VD->isInlineSpecified());
5824 Record.AddVarDeclInit(VD);
5841 NonAffectingFileIDs.empty())
5843 auto It = llvm::lower_bound(NonAffectingFileIDs, FID);
5844 unsigned Idx = std::distance(NonAffectingFileIDs.begin(), It);
5845 unsigned Offset = NonAffectingFileIDAdjustments[Idx];
5846 return FileID::get(FID.getOpaqueValue() - Offset);
5849unsigned ASTWriter::getAdjustedNumCreatedFIDs(
FileID FID)
const {
5855 unsigned AdjustedNumCreatedFIDs = 0;
5856 for (
unsigned I = FID.ID, N = I + NumCreatedFIDs; I != N; ++I)
5857 if (IsSLocAffecting[I])
5858 ++AdjustedNumCreatedFIDs;
5859 return AdjustedNumCreatedFIDs;
5875 return Offset - getAdjustment(Offset);
5880 if (NonAffectingRanges.empty())
5886 if (Offset > NonAffectingRanges.back().getEnd().getOffset())
5887 return NonAffectingOffsetAdjustments.back();
5889 if (Offset < NonAffectingRanges.front().getBegin().getOffset())
5896 auto It = llvm::lower_bound(NonAffectingRanges, Offset, Contains);
5897 unsigned Idx = std::distance(NonAffectingRanges.begin(), It);
5898 return NonAffectingOffsetAdjustments[Idx];
5902 Record.push_back(getAdjustedFileID(FID).getOpaqueValue());
5907 unsigned BaseOffset = 0;
5908 unsigned ModuleFileIndex = 0;
5915 SourceManager::MaxLoadedOffset -
Loc.getOffset() - 1);
5916 assert(SLocMapI !=
getChain()->GlobalSLocOffsetMap.end() &&
5917 "Corrupted global sloc offset map");
5922 ModuleFileIndex = F->
Index + 1;
5931 Loc = getAdjustedLocation(
Loc);
5969 MacroInfoToEmitData Info = { Name, MI, ID };
5970 MacroInfosToEmit.push_back(Info);
5979 assert(MacroIDs.contains(MI) &&
"Macro not emitted!");
5980 return MacroIDs[MI];
5984 return IdentMacroDirectivesOffsetMap.lookup(Name);
5988 Record->push_back(Writer->getSelectorRef(SelRef));
5997 if (SID == 0 && Chain) {
6001 SID = SelectorIDs[Sel];
6004 SID = NextSelectorID++;
6005 SelectorIDs[Sel] = SID;
6047 bool InfoHasSameExpr
6049 Record->push_back(InfoHasSameExpr);
6050 if (InfoHasSameExpr)
6068 TypeLocWriter TLW(*
this,
Seq);
6077template <
typename IdxForTypeTy>
6079 IdxForTypeTy IdxForType) {
6083 unsigned FastQuals =
T.getLocalFastQualifiers();
6084 T.removeLocalFastQualifiers();
6086 if (
T.hasLocalNonFastQualifiers())
6087 return IdxForType(
T).asTypeID(FastQuals);
6089 assert(!
T.hasLocalQualifiers());
6091 if (
const BuiltinType *BT = dyn_cast<BuiltinType>(
T.getTypePtr()))
6099 return IdxForType(
T).asTypeID(FastQuals);
6107 assert(!
T.getLocalFastQualifiers());
6111 if (DoneWritingDeclsAndTypes) {
6112 assert(0 &&
"New type seen after serializing all the types to emit!");
6119 DeclTypesToEmit.push(
T);
6137 assert(WritingAST &&
"Cannot request a declaration ID before AST writing");
6144 if (
auto *
Iter = DeclUpdatesFromGMF.find(D);
6145 Iter != DeclUpdatesFromGMF.end()) {
6147 DeclUpdates[D].push_back(
Update);
6148 DeclUpdatesFromGMF.erase(
Iter);
6160 assert(!(
reinterpret_cast<uintptr_t>(D) & 0x01) &&
"Invalid decl pointer");
6162 if (ID.isInvalid()) {
6163 if (DoneWritingDeclsAndTypes) {
6164 assert(0 &&
"New decl seen after serializing all the decls to emit!");
6171 DeclTypesToEmit.push(
const_cast<Decl *
>(D));
6186 assert(DeclIDs.contains(D) &&
"Declaration not emitted!");
6193 assert(DoneWritingDeclsAndTypes &&
6194 "wasDeclEmitted should only be called after writing declarations");
6199 bool Emitted = DeclIDs.contains(D);
6200 assert((Emitted || GeneratingReducedBMI) &&
6201 "The declaration can only be omitted in reduced BMI.");
6206 assert(ID.isValid());
6220 if (isa<ParmVarDecl, TemplateTemplateParmDecl>(D))
6225 assert(
SM.isLocalSourceLocation(FileLoc));
6228 std::tie(FID, Offset) =
SM.getDecomposedLoc(FileLoc);
6231 assert(
SM.getSLocEntry(FID).isFile());
6232 assert(IsSLocAffecting[FID.ID]);
6234 std::unique_ptr<DeclIDInFileInfo> &Info = FileDeclIDs[FID];
6236 Info = std::make_unique<DeclIDInFileInfo>();
6238 std::pair<unsigned, LocalDeclID> LocDecl(Offset, ID);
6239 LocDeclIDsTy &Decls = Info->DeclIDs;
6240 Decls.push_back(LocDecl);
6245 "expected an anonymous declaration");
6249 auto It = AnonymousDeclarationNumbers.find(D);
6250 if (It == AnonymousDeclarationNumbers.end()) {
6253 AnonymousDeclarationNumbers[ND] = Number;
6256 It = AnonymousDeclarationNumbers.find(D);
6257 assert(It != AnonymousDeclarationNumbers.end() &&
6258 "declaration not found within its lexical context");
6266 switch (Name.getNameKind()) {
6313 NestedNames.push_back(NNS);
6317 Record->push_back(NestedNames.size());
6318 while(!NestedNames.empty()) {
6319 NNS = NestedNames.pop_back_val();
6361 assert(TemplateParams &&
"No TemplateParams!");
6367 for (
const auto &
P : *TemplateParams)
6373 Record->push_back(
false);
6380 assert(TemplateArgs &&
"No TemplateArgs!");
6382 for (
int i = 0, e = TemplateArgs->
size(); i != e; ++i)
6388 assert(ASTTemplArgList &&
"No ASTTemplArgList!");
6400 I =
Set.begin(), E =
Set.end(); I != E; ++I) {
6402 Record->push_back(I.getAccess());
6410 Record->push_back(
Base.getAccessSpecifierAsWritten());
6411 Record->push_back(
Base.getInheritConstructors());
6424 for (
auto &
Base : Bases)
6442 for (
auto *
Init : CtorInits) {
6443 if (
Init->isBaseInitializer()) {
6447 }
else if (
Init->isDelegatingInitializer()) {
6450 }
else if (
Init->isMemberInitializer()){
6463 if (
Init->isWritten())
6477 auto &
Data = D->data();
6484 DefinitionBits.
addBit(ShouldSkipCheckingODR);
6486#define FIELD(Name, Width, Merge) \
6487 if (!DefinitionBits.canWriteNextNBits(Width)) { \
6488 Record->push_back(DefinitionBits); \
6489 DefinitionBits.reset(0); \
6491 DefinitionBits.addBits(Data.Name, Width);
6493#include "clang/AST/CXXRecordDeclDefinitionBits.def"
6496 Record->push_back(DefinitionBits);
6499 if (!ShouldSkipCheckingODR)
6504 bool ModulesDebugInfo =
6505 Writer->Context->getLangOpts().ModulesDebugInfo && !D->
isDependentType();
6506 Record->push_back(ModulesDebugInfo);
6507 if (ModulesDebugInfo)
6508 Writer->AddDeclRef(D, Writer->ModularCodegenDecls);
6513 Record->push_back(
Data.ComputedVisibleConversions);
6514 if (
Data.ComputedVisibleConversions)
6518 if (!
Data.IsLambda) {
6520 if (
Data.NumBases > 0)
6525 if (
Data.NumVBases > 0)
6530 auto &Lambda = D->getLambdaData();
6533 LambdaBits.
addBits(Lambda.DependencyKind, 2);
6534 LambdaBits.
addBit(Lambda.IsGenericLambda);
6535 LambdaBits.
addBits(Lambda.CaptureDefault, 2);
6536 LambdaBits.
addBits(Lambda.NumCaptures, 15);
6537 LambdaBits.
addBit(Lambda.HasKnownInternalLinkage);
6538 Record->push_back(LambdaBits);
6540 Record->push_back(Lambda.NumExplicitCaptures);
6541 Record->push_back(Lambda.ManglingNumber);
6546 for (
unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
6553 Record->push_back(CaptureBits);
6555 switch (
Capture.getCaptureKind()) {
6582 Val |= (ES->HasConstantInitialization ? 2 : 0);
6583 Val |= (ES->HasConstantDestruction ? 4 : 0);
6597void ASTWriter::ReaderInitialized(
ASTReader *Reader) {
6598 assert(Reader &&
"Cannot remove chain");
6599 assert((!Chain || Chain == Reader) &&
"Cannot replace chain");
6600 assert(FirstDeclID == NextDeclID &&
6601 FirstTypeID == NextTypeID &&
6602 FirstIdentID == NextIdentID &&
6603 FirstMacroID == NextMacroID &&
6604 FirstSubmoduleID == NextSubmoduleID &&
6605 FirstSelectorID == NextSelectorID &&
6606 "Setting chain after writing has started.");
6618 NextDeclID = FirstDeclID;
6619 NextTypeID = FirstTypeID;
6620 NextIdentID = FirstIdentID;
6621 NextMacroID = FirstMacroID;
6622 NextSelectorID = FirstSelectorID;
6623 NextSubmoduleID = FirstSubmoduleID;
6635 MacroID &StoredID = MacroIDs[MI];
6660 assert(!MacroDefinitions.contains(MD));
6661 MacroDefinitions[MD] =
ID;
6665 assert(!SubmoduleIDs.contains(Mod));
6666 SubmoduleIDs[Mod] =
ID;
6669void ASTWriter::CompletedTagDefinition(
const TagDecl *D) {
6672 assert(!WritingAST &&
"Already writing the AST!");
6673 if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
6675 if (RD->isFromASTFile()) {
6680 "completed a tag from another module but not by instantiation?");
6681 DeclUpdates[RD].push_back(
6696void ASTWriter::AddedVisibleDecl(
const DeclContext *DC,
const Decl *D) {
6699 "Should not add lookup results to non-lookup contexts!");
6702 if (isa<TranslationUnitDecl>(DC))
6710 !isa<FunctionTemplateDecl>(D))
6720 assert(!WritingAST &&
"Already writing the AST!");
6721 if (UpdatedDeclContexts.insert(DC) && !cast<Decl>(DC)->isFromASTFile()) {
6725 llvm::append_range(DeclsToEmitEvenIfUnreferenced, DC->
decls());
6727 DeclsToEmitEvenIfUnreferenced.push_back(D);
6739 if (!isa<CXXMethodDecl>(D))
6744 assert(!WritingAST &&
"Already writing the AST!");
6748void ASTWriter::ResolvedExceptionSpec(
const FunctionDecl *FD) {
6750 assert(!DoneWritingDeclsAndTypes &&
"Already done writing updates!");
6757 ->castAs<FunctionProtoType>()
6758 ->getExceptionSpecType()))
6765 assert(!WritingAST &&
"Already writing the AST!");
6768 DeclUpdates[D].push_back(
6777 assert(!WritingAST &&
"Already writing the AST!");
6778 assert(
Delete &&
"Not given an operator delete");
6785void ASTWriter::CompletedImplicitDefinition(
const FunctionDecl *D) {
6787 assert(!WritingAST &&
"Already writing the AST!");
6795void ASTWriter::VariableDefinitionInstantiated(
const VarDecl *D) {
6797 assert(!WritingAST &&
"Already writing the AST!");
6804void ASTWriter::FunctionDefinitionInstantiated(
const FunctionDecl *D) {
6806 assert(!WritingAST &&
"Already writing the AST!");
6813void ASTWriter::InstantiationRequested(
const ValueDecl *D) {
6815 assert(!WritingAST &&
"Already writing the AST!");
6822 if (
auto *VD = dyn_cast<VarDecl>(D))
6823 POI = VD->getPointOfInstantiation();
6825 POI = cast<FunctionDecl>(D)->getPointOfInstantiation();
6829void ASTWriter::DefaultArgumentInstantiated(
const ParmVarDecl *D) {
6831 assert(!WritingAST &&
"Already writing the AST!");
6835 DeclUpdates[D].push_back(
6839void ASTWriter::DefaultMemberInitializerInstantiated(
const FieldDecl *D) {
6840 assert(!WritingAST &&
"Already writing the AST!");
6844 DeclUpdates[D].push_back(
6851 assert(!WritingAST &&
"Already writing the AST!");
6855 assert(IFD->
getDefinition() &&
"Category on a class without a definition?");
6856 ObjCClassesWithCategories.insert(
6860void ASTWriter::DeclarationMarkedUsed(
const Decl *D) {
6862 assert(!WritingAST &&
"Already writing the AST!");
6874void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(
const Decl *D) {
6876 assert(!WritingAST &&
"Already writing the AST!");
6883void ASTWriter::DeclarationMarkedOpenMPAllocate(
const Decl *D,
const Attr *A) {
6885 assert(!WritingAST &&
"Already writing the AST!");
6892void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(
const Decl *D,
6895 assert(!WritingAST &&
"Already writing the AST!");
6899 DeclUpdates[D].push_back(
6903void ASTWriter::RedefinedHiddenDefinition(
const NamedDecl *D,
Module *M) {
6905 assert(!WritingAST &&
"Already writing the AST!");
6910void ASTWriter::AddedAttributeToRecord(
const Attr *
Attr,
6913 assert(!WritingAST &&
"Already writing the AST!");
6914 if (!
Record->isFromASTFile())
6919void ASTWriter::AddedCXXTemplateSpecialization(
6921 assert(!WritingAST &&
"Already writing the AST!");
6928 DeclsToEmitEvenIfUnreferenced.push_back(D);
6931void ASTWriter::AddedCXXTemplateSpecialization(
6933 assert(!WritingAST &&
"Already writing the AST!");
6940 DeclsToEmitEvenIfUnreferenced.push_back(D);
6945 assert(!WritingAST &&
"Already writing the AST!");
6952 DeclsToEmitEvenIfUnreferenced.push_back(D);
6966#define GEN_CLANG_CLAUSE_CLASS
6967#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
6968#include "llvm/Frontend/OpenMP/OMP.inc"
6977 OMPClauseWriter(*this).writeClause(
C);
6980void OMPClauseWriter::writeClause(
OMPClause *
C) {
6981 Record.push_back(
unsigned(
C->getClauseKind()));
6983 Record.AddSourceLocation(
C->getBeginLoc());
6984 Record.AddSourceLocation(
C->getEndLoc());
6988 Record.push_back(uint64_t(
C->getCaptureRegion()));
6989 Record.AddStmt(
C->getPreInitStmt());
6993 VisitOMPClauseWithPreInit(
C);
6994 Record.AddStmt(
C->getPostUpdateExpr());
6997void OMPClauseWriter::VisitOMPIfClause(
OMPIfClause *
C) {
6998 VisitOMPClauseWithPreInit(
C);
7000 Record.AddSourceLocation(
C->getNameModifierLoc());
7001 Record.AddSourceLocation(
C->getColonLoc());
7002 Record.AddStmt(
C->getCondition());
7003 Record.AddSourceLocation(
C->getLParenLoc());
7007 VisitOMPClauseWithPreInit(
C);
7008 Record.AddStmt(
C->getCondition());
7009 Record.AddSourceLocation(
C->getLParenLoc());
7013 VisitOMPClauseWithPreInit(
C);
7014 Record.AddStmt(
C->getNumThreads());
7015 Record.AddSourceLocation(
C->getLParenLoc());
7019 Record.AddStmt(
C->getSafelen());
7020 Record.AddSourceLocation(
C->getLParenLoc());
7024 Record.AddStmt(
C->getSimdlen());
7025 Record.AddSourceLocation(
C->getLParenLoc());
7029 Record.push_back(
C->getNumSizes());
7030 for (
Expr *Size :
C->getSizesRefs())
7032 Record.AddSourceLocation(
C->getLParenLoc());
7038 Record.AddStmt(
C->getFactor());
7039 Record.AddSourceLocation(
C->getLParenLoc());
7043 Record.AddStmt(
C->getAllocator());
7044 Record.AddSourceLocation(
C->getLParenLoc());
7048 Record.AddStmt(
C->getNumForLoops());
7049 Record.AddSourceLocation(
C->getLParenLoc());
7053 Record.AddStmt(
C->getEventHandler());
7054 Record.AddSourceLocation(
C->getLParenLoc());
7058 Record.push_back(
unsigned(
C->getDefaultKind()));
7059 Record.AddSourceLocation(
C->getLParenLoc());
7060 Record.AddSourceLocation(
C->getDefaultKindKwLoc());
7064 Record.push_back(
unsigned(
C->getProcBindKind()));
7065 Record.AddSourceLocation(
C->getLParenLoc());
7066 Record.AddSourceLocation(
C->getProcBindKindKwLoc());
7070 VisitOMPClauseWithPreInit(
C);
7071 Record.push_back(
C->getScheduleKind());
7072 Record.push_back(
C->getFirstScheduleModifier());
7073 Record.push_back(
C->getSecondScheduleModifier());
7074 Record.AddStmt(
C->getChunkSize());
7075 Record.AddSourceLocation(
C->getLParenLoc());
7076 Record.AddSourceLocation(
C->getFirstScheduleModifierLoc());
7077 Record.AddSourceLocation(
C->getSecondScheduleModifierLoc());
7078 Record.AddSourceLocation(
C->getScheduleKindLoc());
7079 Record.AddSourceLocation(
C->getCommaLoc());
7083 Record.push_back(
C->getLoopNumIterations().size());
7084 Record.AddStmt(
C->getNumForLoops());
7085 for (
Expr *NumIter :
C->getLoopNumIterations())
7087 for (
unsigned I = 0, E =
C->getLoopNumIterations().size(); I <E; ++I)
7088 Record.AddStmt(
C->getLoopCounter(I));
7089 Record.AddSourceLocation(
C->getLParenLoc());
7103 Record.push_back(
C->isExtended() ? 1 : 0);
7104 if (
C->isExtended()) {
7105 Record.AddSourceLocation(
C->getLParenLoc());
7106 Record.AddSourceLocation(
C->getArgumentLoc());
7107 Record.writeEnum(
C->getDependencyKind());
7117 Record.AddSourceLocation(
C->getLParenLoc());
7118 Record.AddSourceLocation(
C->getFailParameterLoc());
7119 Record.writeEnum(
C->getFailParameter());
7141 Record.push_back(
C->varlist_size());
7142 for (
Expr *VE :
C->varlists())
7144 Record.writeBool(
C->getIsTarget());
7145 Record.writeBool(
C->getIsTargetSync());
7146 Record.AddSourceLocation(
C->getLParenLoc());
7147 Record.AddSourceLocation(
C->getVarLoc());
7151 Record.AddStmt(
C->getInteropVar());
7152 Record.AddSourceLocation(
C->getLParenLoc());
7153 Record.AddSourceLocation(
C->getVarLoc());
7157 Record.AddStmt(
C->getInteropVar());
7158 Record.AddSourceLocation(
C->getLParenLoc());
7159 Record.AddSourceLocation(
C->getVarLoc());
7163 VisitOMPClauseWithPreInit(
C);
7164 Record.AddStmt(
C->getCondition());
7165 Record.AddSourceLocation(
C->getLParenLoc());
7169 VisitOMPClauseWithPreInit(
C);
7170 Record.AddStmt(
C->getCondition());
7171 Record.AddSourceLocation(
C->getLParenLoc());
7175 VisitOMPClauseWithPreInit(
C);
7176 Record.AddStmt(
C->getThreadID());
7177 Record.AddSourceLocation(
C->getLParenLoc());
7181 Record.AddStmt(
C->getAlignment());
7182 Record.AddSourceLocation(
C->getLParenLoc());
7186 Record.push_back(
C->varlist_size());
7187 Record.AddSourceLocation(
C->getLParenLoc());
7188 for (
auto *VE :
C->varlists()) {
7191 for (
auto *VE :
C->private_copies()) {
7197 Record.push_back(
C->varlist_size());
7198 VisitOMPClauseWithPreInit(
C);
7199 Record.AddSourceLocation(
C->getLParenLoc());
7200 for (
auto *VE :
C->varlists()) {
7203 for (
auto *VE :
C->private_copies()) {
7206 for (
auto *VE :
C->inits()) {
7212 Record.push_back(
C->varlist_size());
7213 VisitOMPClauseWithPostUpdate(
C);
7214 Record.AddSourceLocation(
C->getLParenLoc());
7215 Record.writeEnum(
C->getKind());
7216 Record.AddSourceLocation(
C->getKindLoc());
7217 Record.AddSourceLocation(
C->getColonLoc());
7218 for (
auto *VE :
C->varlists())
7220 for (
auto *E :
C->private_copies())
7222 for (
auto *E :
C->source_exprs())
7224 for (
auto *E :
C->destination_exprs())
7226 for (
auto *E :
C->assignment_ops())
7231 Record.push_back(
C->varlist_size());
7232 Record.AddSourceLocation(
C->getLParenLoc());
7233 for (
auto *VE :
C->varlists())
7238 Record.push_back(
C->varlist_size());
7239 Record.writeEnum(
C->getModifier());
7240 VisitOMPClauseWithPostUpdate(
C);
7241 Record.AddSourceLocation(
C->getLParenLoc());
7242 Record.AddSourceLocation(
C->getModifierLoc());
7243 Record.AddSourceLocation(
C->getColonLoc());
7244 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7245 Record.AddDeclarationNameInfo(
C->getNameInfo());
7246 for (
auto *VE :
C->varlists())
7248 for (
auto *VE :
C->privates())
7250 for (
auto *E :
C->lhs_exprs())
7252 for (
auto *E :
C->rhs_exprs())
7254 for (
auto *E :
C->reduction_ops())
7256 if (
C->getModifier() == clang::OMPC_REDUCTION_inscan) {
7257 for (
auto *E :
C->copy_ops())
7259 for (
auto *E :
C->copy_array_temps())
7261 for (
auto *E :
C->copy_array_elems())
7267 Record.push_back(
C->varlist_size());
7268 VisitOMPClauseWithPostUpdate(
C);
7269 Record.AddSourceLocation(
C->getLParenLoc());
7270 Record.AddSourceLocation(
C->getColonLoc());
7271 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7272 Record.AddDeclarationNameInfo(
C->getNameInfo());
7273 for (
auto *VE :
C->varlists())
7275 for (
auto *VE :
C->privates())
7277 for (
auto *E :
C->lhs_exprs())
7279 for (
auto *E :
C->rhs_exprs())
7281 for (
auto *E :
C->reduction_ops())
7286 Record.push_back(
C->varlist_size());
7287 VisitOMPClauseWithPostUpdate(
C);
7288 Record.AddSourceLocation(
C->getLParenLoc());
7289 Record.AddSourceLocation(
C->getColonLoc());
7290 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7291 Record.AddDeclarationNameInfo(
C->getNameInfo());
7292 for (
auto *VE :
C->varlists())
7294 for (
auto *VE :
C->privates())
7296 for (
auto *E :
C->lhs_exprs())
7298 for (
auto *E :
C->rhs_exprs())
7300 for (
auto *E :
C->reduction_ops())
7302 for (
auto *E :
C->taskgroup_descriptors())
7307 Record.push_back(
C->varlist_size());
7308 VisitOMPClauseWithPostUpdate(
C);
7309 Record.AddSourceLocation(
C->getLParenLoc());
7310 Record.AddSourceLocation(
C->getColonLoc());
7311 Record.push_back(
C->getModifier());
7312 Record.AddSourceLocation(
C->getModifierLoc());
7313 for (
auto *VE :
C->varlists()) {
7316 for (
auto *VE :
C->privates()) {
7319 for (
auto *VE :
C->inits()) {
7322 for (
auto *VE :
C->updates()) {
7325 for (
auto *VE :
C->finals()) {
7329 Record.AddStmt(
C->getCalcStep());
7330 for (
auto *VE :
C->used_expressions())
7335 Record.push_back(
C->varlist_size());
7336 Record.AddSourceLocation(
C->getLParenLoc());
7337 Record.AddSourceLocation(
C->getColonLoc());
7338 for (
auto *VE :
C->varlists())
7340 Record.AddStmt(
C->getAlignment());
7344 Record.push_back(
C->varlist_size());
7345 Record.AddSourceLocation(
C->getLParenLoc());
7346 for (
auto *VE :
C->varlists())
7348 for (
auto *E :
C->source_exprs())
7350 for (
auto *E :
C->destination_exprs())
7352 for (
auto *E :
C->assignment_ops())
7357 Record.push_back(
C->varlist_size());
7358 Record.AddSourceLocation(
C->getLParenLoc());
7359 for (
auto *VE :
C->varlists())
7361 for (
auto *E :
C->source_exprs())
7363 for (
auto *E :
C->destination_exprs())
7365 for (
auto *E :
C->assignment_ops())
7370 Record.push_back(
C->varlist_size());
7371 Record.AddSourceLocation(
C->getLParenLoc());
7372 for (
auto *VE :
C->varlists())
7377 Record.AddStmt(
C->getDepobj());
7378 Record.AddSourceLocation(
C->getLParenLoc());
7382 Record.push_back(
C->varlist_size());
7383 Record.push_back(
C->getNumLoops());
7384 Record.AddSourceLocation(
C->getLParenLoc());
7385 Record.AddStmt(
C->getModifier());
7386 Record.push_back(
C->getDependencyKind());
7387 Record.AddSourceLocation(
C->getDependencyLoc());
7388 Record.AddSourceLocation(
C->getColonLoc());
7389 Record.AddSourceLocation(
C->getOmpAllMemoryLoc());
7390 for (
auto *VE :
C->varlists())
7392 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
7393 Record.AddStmt(
C->getLoopData(I));
7397 VisitOMPClauseWithPreInit(
C);
7398 Record.writeEnum(
C->getModifier());
7399 Record.AddStmt(
C->getDevice());
7400 Record.AddSourceLocation(
C->getModifierLoc());
7401 Record.AddSourceLocation(
C->getLParenLoc());
7405 Record.push_back(
C->varlist_size());
7406 Record.push_back(
C->getUniqueDeclarationsNum());
7407 Record.push_back(
C->getTotalComponentListNum());
7408 Record.push_back(
C->getTotalComponentsNum());
7409 Record.AddSourceLocation(
C->getLParenLoc());
7410 bool HasIteratorModifier =
false;
7412 Record.push_back(
C->getMapTypeModifier(I));
7413 Record.AddSourceLocation(
C->getMapTypeModifierLoc(I));
7414 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
7415 HasIteratorModifier =
true;
7417 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7418 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7419 Record.push_back(
C->getMapType());
7420 Record.AddSourceLocation(
C->getMapLoc());
7421 Record.AddSourceLocation(
C->getColonLoc());
7422 for (
auto *E :
C->varlists())
7424 for (
auto *E :
C->mapperlists())
7426 if (HasIteratorModifier)
7427 Record.AddStmt(
C->getIteratorModifier());
7428 for (
auto *D :
C->all_decls())
7430 for (
auto N :
C->all_num_lists())
7432 for (
auto N :
C->all_lists_sizes())
7434 for (
auto &M :
C->all_components()) {
7435 Record.AddStmt(M.getAssociatedExpression());
7436 Record.AddDeclRef(M.getAssociatedDeclaration());
7441 Record.push_back(
C->varlist_size());
7442 Record.AddSourceLocation(
C->getLParenLoc());
7443 Record.AddSourceLocation(
C->getColonLoc());
7444 Record.AddStmt(
C->getAllocator());
7445 for (
auto *VE :
C->varlists())
7450 VisitOMPClauseWithPreInit(
C);
7451 Record.AddStmt(
C->getNumTeams());
7452 Record.AddSourceLocation(
C->getLParenLoc());
7456 VisitOMPClauseWithPreInit(
C);
7457 Record.AddStmt(
C->getThreadLimit());
7458 Record.AddSourceLocation(
C->getLParenLoc());
7462 VisitOMPClauseWithPreInit(
C);
7463 Record.AddStmt(
C->getPriority());
7464 Record.AddSourceLocation(
C->getLParenLoc());
7468 VisitOMPClauseWithPreInit(
C);
7469 Record.writeEnum(
C->getModifier());
7470 Record.AddStmt(
C->getGrainsize());
7471 Record.AddSourceLocation(
C->getModifierLoc());
7472 Record.AddSourceLocation(
C->getLParenLoc());
7476 VisitOMPClauseWithPreInit(
C);
7477 Record.writeEnum(
C->getModifier());
7478 Record.AddStmt(
C->getNumTasks());
7479 Record.AddSourceLocation(
C->getModifierLoc());
7480 Record.AddSourceLocation(
C->getLParenLoc());
7485 Record.AddSourceLocation(
C->getLParenLoc());
7489 VisitOMPClauseWithPreInit(
C);
7490 Record.push_back(
C->getDistScheduleKind());
7491 Record.AddStmt(
C->getChunkSize());
7492 Record.AddSourceLocation(
C->getLParenLoc());
7493 Record.AddSourceLocation(
C->getDistScheduleKindLoc());
7494 Record.AddSourceLocation(
C->getCommaLoc());
7498 Record.push_back(
C->getDefaultmapKind());
7499 Record.push_back(
C->getDefaultmapModifier());
7500 Record.AddSourceLocation(
C->getLParenLoc());
7501 Record.AddSourceLocation(
C->getDefaultmapModifierLoc());
7502 Record.AddSourceLocation(
C->getDefaultmapKindLoc());
7505void OMPClauseWriter::VisitOMPToClause(
OMPToClause *
C) {
7506 Record.push_back(
C->varlist_size());
7507 Record.push_back(
C->getUniqueDeclarationsNum());
7508 Record.push_back(
C->getTotalComponentListNum());
7509 Record.push_back(
C->getTotalComponentsNum());
7510 Record.AddSourceLocation(
C->getLParenLoc());
7512 Record.push_back(
C->getMotionModifier(I));
7513 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
7515 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7516 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7517 Record.AddSourceLocation(
C->getColonLoc());
7518 for (
auto *E :
C->varlists())
7520 for (
auto *E :
C->mapperlists())
7522 for (
auto *D :
C->all_decls())
7524 for (
auto N :
C->all_num_lists())
7526 for (
auto N :
C->all_lists_sizes())
7528 for (
auto &M :
C->all_components()) {
7529 Record.AddStmt(M.getAssociatedExpression());
7530 Record.writeBool(M.isNonContiguous());
7531 Record.AddDeclRef(M.getAssociatedDeclaration());
7536 Record.push_back(
C->varlist_size());
7537 Record.push_back(
C->getUniqueDeclarationsNum());
7538 Record.push_back(
C->getTotalComponentListNum());
7539 Record.push_back(
C->getTotalComponentsNum());
7540 Record.AddSourceLocation(
C->getLParenLoc());
7542 Record.push_back(
C->getMotionModifier(I));
7543 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
7545 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7546 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7547 Record.AddSourceLocation(
C->getColonLoc());
7548 for (
auto *E :
C->varlists())
7550 for (
auto *E :
C->mapperlists())
7552 for (
auto *D :
C->all_decls())
7554 for (
auto N :
C->all_num_lists())
7556 for (
auto N :
C->all_lists_sizes())
7558 for (
auto &M :
C->all_components()) {
7559 Record.AddStmt(M.getAssociatedExpression());
7560 Record.writeBool(M.isNonContiguous());
7561 Record.AddDeclRef(M.getAssociatedDeclaration());
7566 Record.push_back(
C->varlist_size());
7567 Record.push_back(
C->getUniqueDeclarationsNum());
7568 Record.push_back(
C->getTotalComponentListNum());
7569 Record.push_back(
C->getTotalComponentsNum());
7570 Record.AddSourceLocation(
C->getLParenLoc());
7571 for (
auto *E :
C->varlists())
7573 for (
auto *VE :
C->private_copies())
7575 for (
auto *VE :
C->inits())
7577 for (
auto *D :
C->all_decls())
7579 for (
auto N :
C->all_num_lists())
7581 for (
auto N :
C->all_lists_sizes())
7583 for (
auto &M :
C->all_components()) {
7584 Record.AddStmt(M.getAssociatedExpression());
7585 Record.AddDeclRef(M.getAssociatedDeclaration());
7590 Record.push_back(
C->varlist_size());
7591 Record.push_back(
C->getUniqueDeclarationsNum());
7592 Record.push_back(
C->getTotalComponentListNum());
7593 Record.push_back(
C->getTotalComponentsNum());
7594 Record.AddSourceLocation(
C->getLParenLoc());
7595 for (
auto *E :
C->varlists())
7597 for (
auto *D :
C->all_decls())
7599 for (
auto N :
C->all_num_lists())
7601 for (
auto N :
C->all_lists_sizes())
7603 for (
auto &M :
C->all_components()) {
7604 Record.AddStmt(M.getAssociatedExpression());
7605 Record.AddDeclRef(M.getAssociatedDeclaration());
7610 Record.push_back(
C->varlist_size());
7611 Record.push_back(
C->getUniqueDeclarationsNum());
7612 Record.push_back(
C->getTotalComponentListNum());
7613 Record.push_back(
C->getTotalComponentsNum());
7614 Record.AddSourceLocation(
C->getLParenLoc());
7615 for (
auto *E :
C->varlists())
7617 for (
auto *D :
C->all_decls())
7619 for (
auto N :
C->all_num_lists())
7621 for (
auto N :
C->all_lists_sizes())
7623 for (
auto &M :
C->all_components()) {
7624 Record.AddStmt(M.getAssociatedExpression());
7625 Record.AddDeclRef(M.getAssociatedDeclaration());
7630 Record.push_back(
C->varlist_size());
7631 Record.push_back(
C->getUniqueDeclarationsNum());
7632 Record.push_back(
C->getTotalComponentListNum());
7633 Record.push_back(
C->getTotalComponentsNum());
7634 Record.AddSourceLocation(
C->getLParenLoc());
7635 for (
auto *E :
C->varlists())
7637 for (
auto *D :
C->all_decls())
7639 for (
auto N :
C->all_num_lists())
7641 for (
auto N :
C->all_lists_sizes())
7643 for (
auto &M :
C->all_components()) {
7644 Record.AddStmt(M.getAssociatedExpression());
7645 Record.AddDeclRef(M.getAssociatedDeclaration());
7651void OMPClauseWriter::VisitOMPUnifiedSharedMemoryClause(
7660void OMPClauseWriter::VisitOMPAtomicDefaultMemOrderClause(
7662 Record.push_back(
C->getAtomicDefaultMemOrderKind());
7663 Record.AddSourceLocation(
C->getLParenLoc());
7664 Record.AddSourceLocation(
C->getAtomicDefaultMemOrderKindKwLoc());
7667void OMPClauseWriter::VisitOMPAtClause(
OMPAtClause *
C) {
7668 Record.push_back(
C->getAtKind());
7669 Record.AddSourceLocation(
C->getLParenLoc());
7670 Record.AddSourceLocation(
C->getAtKindKwLoc());
7674 Record.push_back(
C->getSeverityKind());
7675 Record.AddSourceLocation(
C->getLParenLoc());
7676 Record.AddSourceLocation(
C->getSeverityKindKwLoc());
7680 Record.AddStmt(
C->getMessageString());
7681 Record.AddSourceLocation(
C->getLParenLoc());
7685 Record.push_back(
C->varlist_size());
7686 Record.AddSourceLocation(
C->getLParenLoc());
7687 for (
auto *VE :
C->varlists())
7689 for (
auto *E :
C->private_refs())
7694 Record.push_back(
C->varlist_size());
7695 Record.AddSourceLocation(
C->getLParenLoc());
7696 for (
auto *VE :
C->varlists())
7701 Record.push_back(
C->varlist_size());
7702 Record.AddSourceLocation(
C->getLParenLoc());
7703 for (
auto *VE :
C->varlists())
7708 Record.writeEnum(
C->getKind());
7709 Record.writeEnum(
C->getModifier());
7710 Record.AddSourceLocation(
C->getLParenLoc());
7711 Record.AddSourceLocation(
C->getKindKwLoc());
7712 Record.AddSourceLocation(
C->getModifierKwLoc());
7716 Record.push_back(
C->getNumberOfAllocators());
7717 Record.AddSourceLocation(
C->getLParenLoc());
7718 for (
unsigned I = 0, E =
C->getNumberOfAllocators(); I < E; ++I) {
7728 Record.push_back(
C->varlist_size());
7729 Record.AddSourceLocation(
C->getLParenLoc());
7730 Record.AddStmt(
C->getModifier());
7731 Record.AddSourceLocation(
C->getColonLoc());
7732 for (
Expr *E :
C->varlists())
7737 Record.writeEnum(
C->getBindKind());
7738 Record.AddSourceLocation(
C->getLParenLoc());
7739 Record.AddSourceLocation(
C->getBindKindLoc());
7743 VisitOMPClauseWithPreInit(
C);
7745 Record.AddSourceLocation(
C->getLParenLoc());
7749 Record.push_back(
C->varlist_size());
7750 Record.push_back(
C->getNumLoops());
7751 Record.AddSourceLocation(
C->getLParenLoc());
7752 Record.push_back(
C->getDependenceType());
7753 Record.AddSourceLocation(
C->getDependenceLoc());
7754 Record.AddSourceLocation(
C->getColonLoc());
7755 for (
auto *VE :
C->varlists())
7757 for (
unsigned I = 0, E =
C->getNumLoops(); I < E; ++I)
7758 Record.AddStmt(
C->getLoopData(I));
7762 Record.AddAttributes(
C->getAttrs());
7763 Record.AddSourceLocation(
C->getBeginLoc());
7764 Record.AddSourceLocation(
C->getLParenLoc());
7765 Record.AddSourceLocation(
C->getEndLoc());
7772 for (
const auto &
Set : TI->
Sets) {
7779 writeExprRef(
Selector.ScoreOrCondition);
7793 for (
unsigned I = 0, E =
Data->getNumClauses(); I < E; ++I)
7795 if (
Data->hasAssociatedStmt())
7797 for (
unsigned I = 0, E =
Data->getNumChildren(); I < E; ++I)
7803 for (
Expr *E :
C->getVarList())
7809 for (
Expr *E : Exprs)
7818 switch (
C->getClauseKind()) {
7820 const auto *DC = cast<OpenACCDefaultClause>(
C);
7826 const auto *IC = cast<OpenACCIfClause>(
C);
7832 const auto *SC = cast<OpenACCSelfClause>(
C);
7835 if (SC->hasConditionExpr())
7840 const auto *NGC = cast<OpenACCNumGangsClause>(
C);
7843 for (
Expr *E : NGC->getIntExprs())
7848 const auto *NWC = cast<OpenACCNumWorkersClause>(
C);
7854 const auto *NWC = cast<OpenACCVectorLengthClause>(
C);
7860 const auto *PC = cast<OpenACCPrivateClause>(
C);
7866 const auto *FPC = cast<OpenACCFirstPrivateClause>(
C);
7872 const auto *AC = cast<OpenACCAttachClause>(
C);
7878 const auto *DPC = cast<OpenACCDevicePtrClause>(
C);
7884 const auto *NCC = cast<OpenACCNoCreateClause>(
C);
7890 const auto *PC = cast<OpenACCPresentClause>(
C);
7898 const auto *CC = cast<OpenACCCopyClause>(
C);
7906 const auto *CIC = cast<OpenACCCopyInClause>(
C);
7915 const auto *COC = cast<OpenACCCopyOutClause>(
C);
7924 const auto *CC = cast<OpenACCCreateClause>(
C);
7931 const auto *AC = cast<OpenACCAsyncClause>(
C);
7934 if (AC->hasIntExpr())
7939 const auto *WC = cast<OpenACCWaitClause>(
C);
7942 if (
const Expr *DNE = WC->getDevNumExpr())
7951 const auto *DTC = cast<OpenACCDeviceTypeClause>(
C);
7986 llvm_unreachable(
"Clause serialization not yet implemented");
7988 llvm_unreachable(
"Invalid Clause Kind");
Defines the clang::ASTContext interface.
static bool isInterestingIdentifier(ASTReader &Reader, const IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
static NamedDecl * getDeclForLocalLookup(const LangOptions &LangOpts, NamedDecl *D)
Determine the declaration that should be put into the name lookup table to represent the given declar...
static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream)
Create an abbreviation for the SLocEntry that refers to a buffer.
static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec)
static bool IsInternalDeclFromFileContext(const Decl *D)
static TypeID MakeTypeID(ASTContext &Context, QualType T, IdxForTypeTy IdxForType)
static void AddLazyVectorEmiitedDecls(ASTWriter &Writer, Vector &Vec, ASTWriter::RecordData &Record)
static 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 void BackpatchSignatureAt(llvm::BitstreamWriter &Stream, const ASTFileSignature &S, uint64_t BitNo)
static const char * adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir)
Adjusts the given filename to only write out the portion of the filename that is not part of the syst...
static 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 some OpenACC-specific enums and functions.
Defines the clang::OpenCLOptions class.
This file defines OpenMP AST classes for clauses.
Defines the clang::Preprocessor interface.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for Objective-C.
static void EmitBlockID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, RecordDataImpl &Record)
Emits a block ID in the BLOCKINFO block.
static void EmitRecordID(unsigned ID, const char *Name, llvm::BitstreamWriter &Stream, RecordDataImpl &Record)
Emits a record ID in the BLOCKINFO block.
Defines the clang::SourceLocation class and associated facilities.
Defines implementation details of the clang::SourceManager class.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TargetOptions class.
#define 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.
QualType AutoRRefDeductTy
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 writeSourceLocation(SourceLocation Loc)
void AddOffset(uint64_t BitOffset)
Add a bit offset into the record.
void AddTypeRef(QualType T)
Emit a reference to a type.
void writeQualType(QualType T)
void writeOpenACCClauseList(ArrayRef< const OpenACCClause * > Clauses)
Writes out a list of OpenACC clauses.
void AddSourceLocation(SourceLocation Loc, LocSeq *Seq=nullptr)
Emit a source location.
void push_back(uint64_t N)
Minimal vector-like interface.
void AddTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Emits source location information for a type. Does not emit the type.
void AddCXXCtorInitializers(ArrayRef< CXXCtorInitializer * > CtorInits)
Emit a CXXCtorInitializer array.
void AddTemplateParameterList(const TemplateParameterList *TemplateParams)
Emit a template parameter list.
void AddTemplateArgument(const TemplateArgument &Arg)
Emit a template argument.
void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name)
void writeOpenACCIntExprList(ArrayRef< Expr * > Exprs)
void AddAPFloat(const llvm::APFloat &Value)
Emit a floating-point value.
void AddTypeSourceInfo(TypeSourceInfo *TInfo)
Emits a reference to a declarator info.
void AddQualifierInfo(const QualifierInfo &Info)
void writeUInt32(uint32_t Value)
void AddDeclRef(const Decl *D)
Emit a reference to a declaration.
void writeOMPChildren(OMPChildren *Data)
Writes data related to the OpenMP directives.
void AddConceptReference(const ConceptReference *CR)
void AddAPInt(const llvm::APInt &Value)
Emit an integral value.
void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg)
Emits a template argument location info.
void writeOpenACCVarList(const OpenACCClauseWithVarList *C)
void AddAttributes(ArrayRef< const Attr * > Attrs)
Emit a list of attributes.
void AddASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *ASTTemplArgList)
Emits an AST template argument list info.
void AddCXXDefinitionData(const CXXRecordDecl *D)
void AddVarDeclInit(const VarDecl *VD)
Emit information about the initializer of a VarDecl.
void writeStmtRef(const Stmt *S)
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg)
Emits a template argument location.
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)
Emit a nested name specifier with source-location information.
void writeOpenACCClause(const OpenACCClause *C)
Writes out a single OpenACC Clause.
void AddAttr(const Attr *A)
An UnresolvedSet-like class which uses the ASTContext's allocator.
Writes an AST file containing the contents of a translation unit.
serialization::MacroID getMacroID(MacroInfo *MI)
Determine the ID of an already-emitted macro.
ASTFileSignature WriteAST(Sema &SemaRef, StringRef OutputFile, Module *WritingModule, StringRef isysroot, bool ShouldCacheASTInMemory=false)
Write a precompiled header for the given semantic analysis.
void AddEmittedDeclRef(const Decl *D, RecordDataImpl &Record)
void AddSourceRange(SourceRange Range, RecordDataImpl &Record, LocSeq *Seq=nullptr)
Emit a source range.
bool isWritingStdCXXNamedModules() const
void EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, StringRef Path)
Emit the current record with the given path as a blob.
void AddFileID(FileID FID, RecordDataImpl &Record)
Emit a FileID.
void AddPath(StringRef Path, RecordDataImpl &Record)
Add a path to the given record.
unsigned getTypeExtQualAbbrev() const
void AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record)
Add a version tuple to the given record.
bool isGeneratingReducedBMI() const
uint32_t getMacroDirectivesOffset(const IdentifierInfo *Name)
void AddAlignPackInfo(const Sema::AlignPackInfo &Info, RecordDataImpl &Record)
Emit a AlignPackInfo.
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...
bool wasDeclEmitted(const Decl *D) const
Whether or not the declaration got emitted.
void AddString(StringRef Str, RecordDataImpl &Record)
Add a string to the given record.
time_t getTimestampForOutput(const FileEntry *E) const
Get a timestamp for output into the AST file.
LocalDeclID GetDeclRef(const Decl *D)
Force a declaration to be emitted and get its local ID to the module file been writing.
LocalDeclID getDeclID(const Decl *D)
Determine the local declaration ID of an already-emitted declaration.
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
serialization::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
bool getDoneWritingDeclsAndTypes() const
serialization::IdentifierID getIdentifierRef(const IdentifierInfo *II)
Get the unique number used to refer to the given identifier.
unsigned getLocalOrImportedSubmoduleID(const Module *Mod)
Retrieve or create a submodule ID for this module, or return 0 if the submodule is neither local (a s...
void AddToken(const Token &Tok, RecordDataImpl &Record)
Emit a token.
serialization::SelectorID getSelectorRef(Selector Sel)
Get the unique number used to refer to the given selector.
SourceLocationEncoding::RawLocEncoding getRawSourceLocationEncoding(SourceLocation Loc, LocSeq *Seq=nullptr)
Return the raw encodings for source locations.
ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl< char > &Buffer, InMemoryModuleCache &ModuleCache, ArrayRef< std::shared_ptr< ModuleFileExtension > > Extensions, bool IncludeTimestamps=true, bool BuildingImplicitModule=false, bool GeneratingReducedBMI=false)
Create a new precompiled header writer that outputs to the given bitstream.
SmallVector< uint64_t, 64 > RecordData
unsigned getAnonymousDeclarationNumber(const NamedDecl *D)
const LangOptions & getLangOpts() const
void SetSelectorOffset(Selector Sel, uint32_t Offset)
Note that the selector Sel occurs at the given offset within the method pool/selector table.
bool PreparePathForOutput(SmallVectorImpl< char > &Path)
Convert a path from this build process into one that is appropriate for emission in the module file.
void SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset)
Note that the identifier II occurs at the given offset within the identifier table.
void AddDeclRef(const Decl *D, RecordDataImpl &Record)
Emit a reference to a declaration.
Wrapper for source info for array parameter types.
Wrapper for source info for arrays.
SourceLocation getLBracketLoc() const
Expr * getSizeExpr() const
SourceLocation getRBracketLoc() const
SourceLocation getRParenLoc() const
SourceLocation getKWLoc() const
SourceLocation getLParenLoc() const
Attr - This represents one attribute.
attr::Kind getKind() const
SourceLocation getScopeLoc() const
SourceRange getRange() const
const IdentifierInfo * getScopeName() const
bool isRegularKeywordAttribute() const
const IdentifierInfo * getAttrName() const
Kind getParsedKind() const
Type source information for an attributed type.
const Attr * getAttr() const
The type attribute.
SourceLocation getRParenLoc() const
bool isDecltypeAuto() const
bool isConstrained() const
ConceptReference * getConceptReference() const
Type source information for an btf_tag attributed type.
A simple helper class to pack several bits in order into (a) 32 bit integer(s).
void addBits(uint32_t Value, uint32_t BitsWidth)
Wrapper for source info for block pointers.
SourceLocation getCaretLoc() const
Wrapper for source info for builtin types.
SourceLocation getBuiltinLoc() const
TypeSpecifierType getWrittenTypeSpec() const
TypeSpecifierWidth getWrittenWidthSpec() const
bool needsExtraLocalData() const
TypeSpecifierSign getWrittenSignSpec() const
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
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.
bool isFunctionOrMethod() const
StoredDeclsMap * getLookupPtr() const
Retrieve the internal representation of the lookup structure.
A helper iterator adaptor to convert the iterators to SmallVector<SomeDeclID> to the iterators to Sma...
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
GlobalDeclID getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
@ FOK_None
Not a friend object.
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
bool isFromExplicitGlobalModule() const
Whether this declaration comes from explicit global module.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
SourceLocation getLocation() const
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
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
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
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.
bool isNamedModule() const
Does this Module is a named module of a standard named module?
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
std::vector< Conflict > Conflicts
The list of conflicts.
This represents a decl that may have a name.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
SourceRange getLocalSourceRange() const
Retrieve the source range covering just the last part of this nested-name-specifier,...
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
SpecifierKind
The kind of specifier that completes this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
This represents '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
Represents a clause with one or more 'var' objects, represented as an expr, as its arguments.
This is the base type for all OpenACC Clauses.
OpenCL supported extensions and optional core features.
SourceLocation getEllipsisLoc() const
SourceLocation getEllipsisLoc() const
SourceLocation getRParenLoc() const
SourceLocation getLParenLoc() const
Represents a parameter to a function.
SourceLocation getKWLoc() const
Wrapper for source info for pointers.
SourceLocation getStarLoc() const
Iteration over the preprocessed entities.
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
MacroDefinitionRecord * findMacroDefinition(const MacroInfo *MI)
Retrieve the macro definition that corresponds to the given MacroInfo.
const std::vector< SourceRange > & getSkippedRanges()
Retrieve all ranges that got skipped while preprocessing.
iterator local_begin()
Begin iterator for local, non-loaded, preprocessed entities.
iterator local_end()
End iterator for local, non-loaded, preprocessed entities.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::string > MacroIncludes
std::vector< std::string > Includes
bool WriteCommentListToPCH
Whether to write comment locations into the PCH when building it.
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
std::vector< std::pair< std::string, bool > > Macros
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
ArrayRef< ModuleMacro * > getLeafModuleMacros(const IdentifierInfo *II) const
Get the list of leaf (non-overridden) module macros for a name.
ArrayRef< PPConditionalInfo > getPreambleConditionalStack() const
SourceLocation getModuleImportLoc(Module *M) const
bool isRecordingPreamble() const
MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const
Given an identifier, return the latest non-imported macro directive for that identifier.
bool SawDateOrTime() const
Returns true if the preprocessor has seen a use of DATE or TIME in the file so far.
unsigned getCounterValue() const
SourceManager & getSourceManager() const
std::optional< PreambleSkipInfo > getPreambleSkipInfo() const
bool hasRecordedPreamble() const
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.
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.
const IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
void * getAsOpaquePtr() const
unsigned getNumArgs() const
iterator find(Selector Sel)
llvm::DenseMap< Selector, Lists >::iterator iterator
void updateOutOfDateSelector(Selector Sel)
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
static uint32_t getRawEncoding(const AlignPackInfo &Info)
Sema - This implements semantic analysis and AST building for C.
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
DelegatingCtorDeclsType DelegatingCtorDecls
All the delegating constructors seen so far in the file, used for cycle detection at the end of the T...
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.
llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate > > LateParsedTemplateMapT
CXXRecordDecl * getStdBadAlloc() const
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
llvm::DenseMap< CXXRecordDecl *, bool > VTablesUsed
The set of classes whose vtables have been used within this translation unit, and a bit that will be ...
PragmaStack< AlignPackInfo > AlignPackStack
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
const llvm::MapVector< FieldDecl *, DeleteLocs > & getMismatchingDeleteExpressions() const
Retrieves list of suspicious delete-expressions that will be checked at the end of translation unit.
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
llvm::MapVector< IdentifierInfo *, llvm::SetVector< WeakInfo, llvm::SmallVector< WeakInfo, 1u >, llvm::SmallDenseSet< WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly > > > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
IdentifierResolver IdResolver
static RawLocEncoding encode(SourceLocation Loc, UIntTy BaseOffset, unsigned BaseModuleFileIndex, SourceLocationSequence *=nullptr)
This object establishes a SourceLocationSequence.
Serialized encoding of a sequence of SourceLocations.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
SourceLocation::UIntTy getNextLocalOffset() const
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.
unsigned getFileIDSize(FileID FID) const
The size of the SLocEntry that FID represents.
bool hasLineTable() const
Determine if the source manager has a line table.
bool isLoadedSourceLocation(SourceLocation Loc) const
Returns true if Loc came from a PCH/Module.
bool isLoadedFileID(FileID FID) const
Returns true if FID came from a PCH/Module.
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file.
LineTableInfo & getLineTable()
Retrieve the stored line table.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
One instance of this struct is kept for every file loaded or used.
OptionalFileEntryRef ContentsEntry
References the file which the contents were actually loaded from.
unsigned IsTransient
True if this file may be transient, that is, if it might not exist at some later point in time when t...
std::optional< llvm::MemoryBufferRef > getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM, SourceLocation Loc=SourceLocation()) const
Returns the memory buffer for the associated content.
unsigned BufferOverridden
Indicates whether the buffer itself was provided to override the actual file contents.
OptionalFileEntryRef OrigEntry
Reference to the file entry representing this ContentCache.
Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded,...
SourceLocation getExpansionLocStart() const
bool isExpansionTokenRange() const
SourceLocation getSpellingLoc() const
bool isMacroArgExpansion() const
SourceLocation getExpansionLocEnd() const
Information about a FileID, basically just the logical file that it represents and include stack info...
const ContentCache & getContentCache() const
This is a discriminated union of FileInfo and ExpansionInfo.
SourceLocation::UIntTy getOffset() const
const FileInfo & getFile() const
const ExpansionInfo & getExpansion() const
An array of decls optimized for the common case of only containing one entry.
Wrapper for substituted template type parameters.
Wrapper for substituted template type parameters.
Represents the declaration of a struct/union/class/enum.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
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::DeclID BaseDeclID
Base declaration ID for declarations local to this module.
serialization::IdentifierID BaseIdentifierID
Base identifier ID for identifiers local to this module.
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
serialization::TypeID BaseTypeIndex
Base type ID for types local to this module as represented in the global type ID space.
unsigned 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 Index
The index of this module in the list of modules.
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.
TypeID asTypeID(unsigned FastQuals) const
uint32_t getIndex() const
Class that performs name lookup into a DeclContext stored in an AST file.
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.
TypeCode
Record codes for each kind of type.
const unsigned int DECL_UPDATES
Record of updates for a declaration that was modified after being deserialized.
@ PREDEF_TYPE_AUTO_RREF_DEDUCT
The "auto &&" deduction type.
@ PREDEF_TYPE_NULL_ID
The NULL type.
@ PREDEF_TYPE_AUTO_DEDUCT
The "auto" deduction type.
@ CTOR_INITIALIZER_MEMBER
@ CTOR_INITIALIZER_DELEGATING
@ CTOR_INITIALIZER_INDIRECT_MEMBER
@ DECL_EMPTY
An EmptyDecl record.
@ DECL_CXX_BASE_SPECIFIERS
A record containing CXXBaseSpecifiers.
@ DECL_CXX_RECORD
A CXXRecordDecl record.
@ DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION
A VarTemplatePartialSpecializationDecl record.
@ DECL_OMP_ALLOCATE
An OMPAllocateDcl record.
@ DECL_MS_PROPERTY
A MSPropertyDecl record.
@ DECL_REQUIRES_EXPR_BODY
A RequiresExprBodyDecl record.
@ DECL_STATIC_ASSERT
A StaticAssertDecl record.
@ DECL_INDIRECTFIELD
A IndirectFieldDecl record.
@ DECL_TEMPLATE_TEMPLATE_PARM
A TemplateTemplateParmDecl record.
@ DECL_IMPORT
An ImportDecl recording a module import.
@ DECL_ACCESS_SPEC
An AccessSpecDecl record.
@ DECL_OBJC_TYPE_PARAM
An ObjCTypeParamDecl record.
@ DECL_OBJC_CATEGORY_IMPL
A ObjCCategoryImplDecl record.
@ DECL_ENUM_CONSTANT
An EnumConstantDecl record.
@ DECL_PARM_VAR
A ParmVarDecl record.
@ DECL_TYPEDEF
A TypedefDecl record.
@ DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK
A TemplateTemplateParmDecl record that stores an expanded template template parameter pack.
@ DECL_HLSL_BUFFER
A HLSLBufferDecl record.
@ DECL_NAMESPACE_ALIAS
A NamespaceAliasDecl record.
@ DECL_TYPEALIAS
A TypeAliasDecl record.
@ DECL_FUNCTION_TEMPLATE
A FunctionTemplateDecl record.
@ DECL_UNRESOLVED_USING_TYPENAME
An UnresolvedUsingTypenameDecl record.
@ DECL_CLASS_TEMPLATE_SPECIALIZATION
A ClassTemplateSpecializationDecl record.
@ DECL_FILE_SCOPE_ASM
A FileScopeAsmDecl record.
@ DECL_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.
TypeIdx TypeIdxFromBuiltin(const BuiltinType *BT)
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
@ FILE_SYSTEM_OPTIONS
Record code for the filesystem options table.
@ TARGET_OPTIONS
Record code for the target options table.
@ PREPROCESSOR_OPTIONS
Record code for the preprocessor options table.
@ HEADER_SEARCH_OPTIONS
Record code for the headers search options table.
@ LANGUAGE_OPTIONS
Record code for the language options table.
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
@ SUBMODULE_BLOCK_ID
The block containing the submodule structure.
@ PREPROCESSOR_DETAIL_BLOCK_ID
The block containing the detailed preprocessing record.
@ AST_BLOCK_ID
The AST block, which acts as a container around the full AST block.
@ SOURCE_MANAGER_BLOCK_ID
The block containing information about the source manager.
@ CONTROL_BLOCK_ID
The control block, which contains all of the information that needs to be validated prior to committi...
@ DECLTYPES_BLOCK_ID
The block containing the definitions of all of the types and decls used within the AST file.
@ PREPROCESSOR_BLOCK_ID
The block containing information about the preprocessor.
@ COMMENTS_BLOCK_ID
The block containing comments.
@ UNHASHED_CONTROL_BLOCK_ID
A block with unhashed content.
@ EXTENSION_BLOCK_ID
A block containing a module file extension.
@ OPTIONS_BLOCK_ID
The block of configuration options, used to check that a module is being used in a configuration comp...
@ INPUT_FILES_BLOCK_ID
The block of input files, which were used as inputs to create this AST file.
const unsigned VERSION_MINOR
AST file minor version number supported by this version of Clang.
@ SM_SLOC_FILE_ENTRY
Describes a source location entry (SLocEntry) for a file.
@ SM_SLOC_BUFFER_BLOB_COMPRESSED
Describes a zlib-compressed blob that contains the data for a buffer entry.
@ SM_SLOC_BUFFER_ENTRY
Describes a source location entry (SLocEntry) for a buffer.
@ SM_SLOC_BUFFER_BLOB
Describes a blob that contains the data for a buffer entry.
@ SM_SLOC_EXPANSION_ENTRY
Describes a source location entry (SLocEntry) for a macro expansion.
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
DeclIDBase::DeclID DeclID
An ID number that refers to a declaration in an AST file.
@ PP_TOKEN
Describes one token.
@ PP_MACRO_FUNCTION_LIKE
A function-like macro definition.
@ PP_MACRO_OBJECT_LIKE
An object-like macro definition.
@ PP_MACRO_DIRECTIVE_HISTORY
The macro directives history for a particular identifier.
@ PP_MODULE_MACRO
A macro directive exported by a module.
void numberAnonymousDeclsWithin(const DeclContext *DC, Fn Visit)
Visit each declaration within DC that needs an anonymous declaration number and call Visit with the d...
@ MODULE_MAP_FILE
Record code for the module map file that was used to build this AST file.
@ MODULE_DIRECTORY
Record code for the module build directory.
@ 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.
@ 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,.
@ DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD
Record code for lexical and visible block for delayed namespace in reduced BMI.
@ PP_CONDITIONAL_STACK
The stack of open #ifs/#ifdefs recorded in a preamble.
@ REFERENCED_SELECTOR_POOL
Record code for referenced selector pool.
@ SOURCE_LOCATION_OFFSETS
Record code for the table of offsets into the block of source-location information.
@ WEAK_UNDECLARED_IDENTIFIERS
Record code for weak undeclared identifiers.
@ UNDEFINED_BUT_USED
Record code for undefined but used functions and variables that need a definition in this TU.
@ FILE_SORTED_DECLS
Record code for a file sorted array of DeclIDs in a module.
@ MSSTRUCT_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
@ TENTATIVE_DEFINITIONS
Record code for the array of tentative definitions.
@ UNUSED_FILESCOPED_DECLS
Record code for the array of unused file scoped decls.
@ ALIGN_PACK_PRAGMA_OPTIONS
Record code for #pragma align/pack options.
@ IMPORTED_MODULES
Record code for an array of all of the (sub)modules that were imported by the AST file.
@ SELECTOR_OFFSETS
Record code for the table of offsets into the Objective-C method pool.
@ UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES
Record code for potentially unused local typedef names.
@ OPENCL_EXTENSION_TYPES
Record code for types associated with OpenCL extensions.
@ EAGERLY_DESERIALIZED_DECLS
Record code for the array of eagerly deserialized decls.
@ INTERESTING_IDENTIFIERS
A list of "interesting" identifiers.
@ HEADER_SEARCH_TABLE
Record code for header search information.
@ OBJC_CATEGORIES_MAP
Record code for map of Objective-C class definition IDs to the ObjC categories in a module that are a...
@ METADATA_OLD_FORMAT
This is so that older clang versions, before the introduction of the control block,...
@ CUDA_SPECIAL_DECL_REFS
Record code for special CUDA declarations.
@ TU_UPDATE_LEXICAL
Record code for an update to the TU's lexically contained declarations.
@ PPD_SKIPPED_RANGES
A table of skipped ranges within the preprocessing record.
@ IDENTIFIER_TABLE
Record code for the identifier table.
@ SEMA_DECL_REFS
Record code for declarations that Sema keeps references of.
@ OPTIMIZE_PRAGMA_OPTIONS
Record code for #pragma optimize options.
@ MODULE_OFFSET_MAP
Record code for the remapping information used to relate loaded modules to the various offsets and ID...
@ POINTERS_TO_MEMBERS_PRAGMA_OPTIONS
Record code for #pragma ms_struct options.
uint32_t MacroID
An ID number that refers to a macro in an AST file.
uint32_t IdentifierID
An ID number that refers to an identifier 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.
@ Auto
'auto' clause, allowed on 'loop' directives.
@ Bind
'bind' clause, allowed on routine constructs.
@ Gang
'gang' clause, allowed on 'loop' and Combined constructs.
@ Wait
'wait' clause, allowed on Compute, Data, 'update', and Combined constructs.
@ DevicePtr
'deviceptr' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ PCopyOut
'copyout' clause alias 'pcopyout'. Preserved for diagnostic purposes.
@ VectorLength
'vector_length' clause, allowed on 'parallel', 'kernels', 'parallel loop', and 'kernels loop' constru...
@ Async
'async' clause, allowed on Compute, Data, 'update', 'wait', and Combined constructs.
@ PresentOrCreate
'create' clause alias 'present_or_create'.
@ Collapse
'collapse' clause, allowed on 'loop' and Combined constructs.
@ NoHost
'nohost' clause, allowed on 'routine' directives.
@ PresentOrCopy
'copy' clause alias 'present_or_copy'. Preserved for diagnostic purposes.
@ DeviceNum
'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
@ Invalid
Represents an invalid clause, for the purposes of parsing.
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Copy
'copy' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.
@ Worker
'worker' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ DeviceType
'device_type' clause, allowed on Compute, 'data', 'init', 'shutdown', 'set', update',...
@ DefaultAsync
'default_async' clause, allowed on 'set' construct.
@ Attach
'attach' clause, allowed on Compute and Combined constructs, plus 'data' and 'enter data'.
@ NumGangs
'num_gangs' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs.
@ If
'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...
@ Default
'default' clause, allowed on parallel, serial, kernel (and compound) constructs.
@ UseDevice
'use_device' clause, allowed on 'host_data' construct.
@ NoCreate
'no_create' clause, allowed on allowed on Compute and Combined constructs, plus 'data'.
@ PresentOrCopyOut
'copyout' clause alias 'present_or_copyout'.
@ Link
'link' clause, allowed on 'declare' construct.
@ Reduction
'reduction' clause, allowed on Parallel, Serial, Loop, and the combined constructs.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ CopyOut
'copyout' clause, allowed on Compute and Combined constructs, plus 'data', 'exit data',...
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
@ FirstPrivate
'firstprivate' clause, allowed on 'parallel', 'serial', 'parallel loop', and 'serial loop' constructs...
@ Host
'host' clause, allowed on 'update' construct.
@ PCopy
'copy' clause alias 'pcopy'. Preserved for diagnostic purposes.
@ Tile
'tile' clause, allowed on 'loop' and Combined constructs.
@ PCopyIn
'copyin' clause alias 'pcopyin'. Preserved for diagnostic purposes.
@ DeviceResident
'device_resident' clause, allowed on the 'declare' construct.
@ PCreate
'create' clause alias 'pcreate'. Preserved for diagnostic purposes.
@ Present
'present' clause, allowed on Compute and Combined constructs, plus 'data' and 'declare'.
@ DType
'dtype' clause, an alias for 'device_type', stored separately for diagnostic purposes.
@ CopyIn
'copyin' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ Device
'device' clause, allowed on the 'update' construct.
@ Independent
'independent' clause, allowed on 'loop' directives.
@ NumWorkers
'num_workers' clause, allowed on 'parallel', 'kernels', parallel loop', and 'kernels loop' constructs...
@ IfPresent
'if_present' clause, allowed on 'host_data' and 'update' directives.
@ Detach
'detach' clause, allowed on the 'exit data' construct.
@ Delete
'delete' clause, allowed on the 'exit data' construct.
@ PresentOrCopyIn
'copyin' clause alias 'present_or_copyin'.
@ Finalize
'finalize' clause, allowed on 'exit data' directive.
@ 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.
static constexpr unsigned NumberOfOMPMapClauseModifiers
Number of allowed map-type-modifiers.
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
PredefinedDeclIDs
Predefined declaration IDs.
@ PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID
The internal '__NSConstantString' tag type.
@ PREDEF_DECL_TRANSLATION_UNIT_ID
The translation unit.
@ PREDEF_DECL_TYPE_PACK_ELEMENT_ID
The internal '__type_pack_element' template.
@ PREDEF_DECL_OBJC_CLASS_ID
The Objective-C 'Class' type.
@ PREDEF_DECL_BUILTIN_MS_GUID_ID
The predeclared '_GUID' struct.
@ PREDEF_DECL_OBJC_INSTANCETYPE_ID
The internal 'instancetype' typedef.
@ PREDEF_DECL_OBJC_PROTOCOL_ID
The Objective-C 'Protocol' type.
@ PREDEF_DECL_UNSIGNED_INT_128_ID
The unsigned 128-bit integer type.
@ PREDEF_DECL_OBJC_SEL_ID
The Objective-C 'SEL' type.
@ PREDEF_DECL_INT_128_ID
The signed 128-bit integer type.
@ PREDEF_DECL_VA_LIST_TAG
The internal '__va_list_tag' struct, if any.
@ PREDEF_DECL_BUILTIN_MS_VA_LIST_ID
The internal '__builtin_ms_va_list' typedef.
@ PREDEF_DECL_CF_CONSTANT_STRING_ID
The internal '__NSConstantString' typedef.
@ PREDEF_DECL_BUILTIN_VA_LIST_ID
The internal '__builtin_va_list' typedef.
@ PREDEF_DECL_EXTERN_C_CONTEXT_ID
The extern "C" context.
@ PREDEF_DECL_OBJC_ID_ID
The Objective-C 'id' type.
@ PREDEF_DECL_MAKE_INTEGER_SEQ_ID
The internal '__make_integer_seq' template.
@ Property
The type of a property.
@ Result
The result type of a method or function.
bool CanElideDeclDef(const Decl *D)
If we can elide the definition of.
std::pair< IdentifierInfo *, SourceLocation > DeviceTypeArgument
static constexpr unsigned NumberOfOMPMotionModifiers
Number of allowed motion-modifiers.
llvm::hash_code hash_value(const CustomizableOptional< T > &O)
for(const auto &A :T->param_types())
const FunctionProtoType * T
bool shouldSkipCheckingODR(const Decl *D)
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
@ None
The alignment was not explicit in code.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
Diagnostic wrappers for TextAPI types for error reporting.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
The signature of a module, which is a hash of the AST content.
static ASTFileSignature create(std::array< uint8_t, 20 > Bytes)
static ASTFileSignature createDummy()
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments.
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
const DeclarationNameLoc & getInfo() const
Structure used to store a statement, the constant value to which it was evaluated (if any),...
Contains a late templated function.
FPOptions FPO
Floating-point options in the point of definition.
Decl * D
The template function declaration to be late parsed.
Data for list of allocators.
a linked list of methods with the same selector name but different signatures.
ObjCMethodList * getNext() const
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
TemplateParameterList ** TemplParamLists
A new-allocated array of size NumTemplParamLists, containing pointers to the "outer" template paramet...
NestedNameSpecifierLoc QualifierLoc
unsigned NumTemplParamLists
The number of "outer" template parameter lists.
Location information for a TemplateArgument.
SourceLocation getTemplateEllipsisLoc() const
NestedNameSpecifierLoc getTemplateQualifierLoc() const
TypeSourceInfo * getAsTypeSourceInfo() const
SourceLocation getTemplateNameLoc() const
Describes the categories of an Objective-C class.