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(
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);
932 BLOCK(SOURCE_MANAGER_BLOCK);
940 BLOCK(PREPROCESSOR_BLOCK);
948 BLOCK(SUBMODULE_BLOCK);
970 BLOCK(COMMENTS_BLOCK);
974 BLOCK(DECLTYPES_BLOCK);
978 RECORD(TYPE_BLOCK_POINTER);
979 RECORD(TYPE_LVALUE_REFERENCE);
980 RECORD(TYPE_RVALUE_REFERENCE);
981 RECORD(TYPE_MEMBER_POINTER);
982 RECORD(TYPE_CONSTANT_ARRAY);
983 RECORD(TYPE_INCOMPLETE_ARRAY);
984 RECORD(TYPE_VARIABLE_ARRAY);
987 RECORD(TYPE_FUNCTION_NO_PROTO);
988 RECORD(TYPE_FUNCTION_PROTO);
994 RECORD(TYPE_OBJC_INTERFACE);
995 RECORD(TYPE_OBJC_OBJECT_POINTER);
998 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
999 RECORD(TYPE_UNRESOLVED_USING);
1000 RECORD(TYPE_INJECTED_CLASS_NAME);
1001 RECORD(TYPE_OBJC_OBJECT);
1002 RECORD(TYPE_TEMPLATE_TYPE_PARM);
1003 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
1004 RECORD(TYPE_DEPENDENT_NAME);
1005 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
1006 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
1008 RECORD(TYPE_MACRO_QUALIFIED);
1009 RECORD(TYPE_PACK_EXPANSION);
1011 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
1013 RECORD(TYPE_UNARY_TRANSFORM);
1017 RECORD(TYPE_OBJC_TYPE_PARAM);
1095 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
1101 BLOCK(EXTENSION_BLOCK);
1104 BLOCK(UNHASHED_CONTROL_BLOCK);
1123 return Changed | llvm::sys::path::remove_dots(
Path);
1138 assert(
Filename &&
"No file name to adjust?");
1140 if (BaseDir.empty())
1145 for (;
Filename[Pos] && Pos < BaseDir.size(); ++Pos)
1155 if (!llvm::sys::path::is_separator(
Filename[Pos])) {
1156 if (!llvm::sys::path::is_separator(BaseDir.back()))
1173std::pair<ASTFileSignature, ASTFileSignature>
1174ASTWriter::createSignature()
const {
1175 StringRef AllBytes(Buffer.data(), Buffer.size());
1178 Hasher.update(AllBytes.slice(ASTBlockRange.first, ASTBlockRange.second));
1183 Hasher.update(AllBytes.slice(0, UnhashedControlBlockRange.first));
1186 AllBytes.slice(UnhashedControlBlockRange.second, ASTBlockRange.first));
1188 Hasher.update(AllBytes.slice(ASTBlockRange.second, StringRef::npos));
1191 return std::make_pair(ASTBlockHash, Signature);
1196 Hasher.update(StringRef(Buffer.data(), Buffer.size()));
1198 assert(WritingModule);
1203 for (
auto [ExportImported, _] : WritingModule->
Exports)
1204 Hasher.update(ExportImported->Signature);
1228 for (
Module *M : TouchedTopLevelModules)
1229 Hasher.update(M->Signature);
1236 for (uint8_t Byte : S) {
1237 Stream.BackpatchByte(BitNo, Byte);
1249 if (!WritingModule ||
1256 std::tie(ASTBlockHash, Signature) = createSignature();
1264void ASTWriter::writeUnhashedControlBlock(
Preprocessor &PP,
1266 using namespace llvm;
1269 Stream.FlushToWord();
1270 UnhashedControlBlockRange.first = Stream.GetCurrentBitNo() >> 3;
1293 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1295 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1296 unsigned ASTBlockHashAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1299 Stream.EmitRecordWithBlob(ASTBlockHashAbbrev,
Record, Blob);
1300 ASTBlockHashOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1304 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1305 Abbrev->Add(BitCodeAbbrevOp(
SIGNATURE));
1306 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1307 unsigned SignatureAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1310 Stream.EmitRecordWithBlob(SignatureAbbrev,
Record, Blob);
1311 SignatureOffset = Stream.GetCurrentBitNo() - Blob.size() * 8;
1320 if (!HSOpts.ModulesSkipDiagnosticOptions) {
1321#define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1322#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1323 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1324#include "clang/Basic/DiagnosticOptions.def"
1326 for (
unsigned I = 0, N = DiagOpts.
Warnings.size(); I != N; ++I)
1329 for (
unsigned I = 0, N = DiagOpts.
Remarks.size(); I != N; ++I)
1338 if (!HSOpts.ModulesSkipHeaderSearchPaths) {
1340 Record.push_back(HSOpts.UserEntries.size());
1341 for (
unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
1344 Record.push_back(
static_cast<unsigned>(Entry.
Group));
1350 Record.push_back(HSOpts.SystemHeaderPrefixes.size());
1351 for (
unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
1353 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
1357 Record.push_back(HSOpts.VFSOverlayFiles.size());
1358 for (StringRef VFSOverlayFile : HSOpts.VFSOverlayFiles)
1364 if (!HSOpts.ModulesSkipPragmaDiagnosticMappings)
1365 WritePragmaDiagnosticMappings(Diags, WritingModule);
1370 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1372 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1373 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1374 unsigned HSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1376 HSEntryUsage.size()};
1377 Stream.EmitRecordWithBlob(HSUsageAbbrevCode,
Record,
bytes(HSEntryUsage));
1383 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1384 Abbrev->Add(BitCodeAbbrevOp(
VFS_USAGE));
1385 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1386 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1387 unsigned VFSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1389 Stream.EmitRecordWithBlob(VFSUsageAbbrevCode,
Record,
bytes(VFSUsage));
1394 UnhashedControlBlockRange.second = Stream.GetCurrentBitNo() >> 3;
1399 StringRef isysroot) {
1400 using namespace llvm;
1406 auto MetadataAbbrev = std::make_shared<BitCodeAbbrev>();
1407 MetadataAbbrev->Add(BitCodeAbbrevOp(
METADATA));
1408 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1409 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1410 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1411 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1412 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1414 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1415 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1416 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1417 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1418 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));
1419 assert((!WritingModule || isysroot.empty()) &&
1420 "writing module as a relocatable PCH?");
1425 CLANG_VERSION_MAJOR,
1426 CLANG_VERSION_MINOR,
1430 ASTHasCompilerErrors};
1431 Stream.EmitRecordWithBlob(MetadataAbbrevCode,
Record,
1435 if (WritingModule) {
1437 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1439 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1440 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1442 Stream.EmitRecordWithBlob(AbbrevCode,
Record, WritingModule->
Name);
1445 if (WritingModule && WritingModule->
Directory) {
1452 BaseDir.assign(CWD->getName());
1467 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1469 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1470 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1473 Stream.EmitRecordWithBlob(AbbrevCode,
Record, BaseDir);
1477 BaseDirectory.assign(BaseDir.begin(), BaseDir.end());
1478 }
else if (!isysroot.empty()) {
1480 BaseDirectory = std::string(isysroot);
1489 ? Map.getModuleMapFileForUniquing(WritingModule)
1490 ->getNameAsRequested()
1495 if (
auto *AdditionalModMaps =
1496 Map.getAdditionalModuleMapFiles(WritingModule)) {
1497 Record.push_back(AdditionalModMaps->size());
1499 AdditionalModMaps->end());
1519 if (!M.isDirectlyImported())
1522 Record.push_back((
unsigned)M.Kind);
1523 Record.push_back(M.StandardCXXModule);
1528 if (!M.StandardCXXModule) {
1531 Record.push_back(M.Signature ? 0 : M.File.getSize());
1533 llvm::append_range(
Record, M.Signature);
1538 if (!M.StandardCXXModule)
1550#define LANGOPT(Name, Bits, Default, Description) \
1551 Record.push_back(LangOpts.Name);
1552#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1553 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1554#include "clang/Basic/LangOptions.def"
1555#define SANITIZER(NAME, ID) \
1556 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID));
1557#include "clang/Basic/Sanitizers.def"
1597 for (
unsigned I = 0, N = TargetOpts.
Features.size(); I != N; ++I) {
1638 bool WriteMacros = !SkipMacros;
1639 Record.push_back(WriteMacros);
1643 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
1651 for (
unsigned I = 0, N = PPOpts.
Includes.size(); I != N; ++I)
1656 for (
unsigned I = 0, N = PPOpts.
MacroIncludes.size(); I != N; ++I)
1671 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID())) {
1672 auto FileAbbrev = std::make_shared<BitCodeAbbrev>();
1674 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1675 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1676 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));
1688 WriteInputFiles(Context.SourceMgr,
1696struct InputFileEntry {
1700 bool BufferOverridden;
1703 uint32_t ContentHash[2];
1715 assert(IncludeFID.
isValid() &&
"IncludeLoc in invalid file");
1716 if (!IsSLocAffecting[IncludeFID.ID])
1724 using namespace llvm;
1729 auto IFAbbrev = std::make_shared<BitCodeAbbrev>();
1731 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1732 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12));
1733 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
1734 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1735 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1736 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1737 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1738 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
1739 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1740 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));
1743 auto IFHAbbrev = std::make_shared<BitCodeAbbrev>();
1745 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1746 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1747 unsigned IFHAbbrevCode = Stream.EmitAbbrev(std::move(IFHAbbrev));
1749 uint64_t InputFilesOffsetBase = Stream.GetCurrentBitNo();
1752 std::vector<InputFileEntry> UserFiles;
1753 std::vector<InputFileEntry> SystemFiles;
1757 assert(&SourceMgr.
getSLocEntry(FileID::get(I)) == SLoc);
1764 if (!
Cache->OrigEntry)
1768 if (!IsSLocAffecting[I])
1771 InputFileEntry Entry(*
Cache->OrigEntry);
1772 Entry.IsSystemFile =
isSystem(
File.getFileCharacteristic());
1773 Entry.IsTransient =
Cache->IsTransient;
1774 Entry.BufferOverridden =
Cache->BufferOverridden;
1775 Entry.IsTopLevel = getAffectingIncludeLoc(SourceMgr,
File).
isInvalid();
1782 auto MemBuff =
Cache->getBufferIfLoaded();
1784 ContentHash = xxh3_64bits(MemBuff->getBuffer());
1787 << Entry.File.getName();
1789 Entry.ContentHash[0] = uint32_t(ContentHash);
1790 Entry.ContentHash[1] = uint32_t(ContentHash >> 32);
1791 if (Entry.IsSystemFile)
1792 SystemFiles.push_back(Entry);
1794 UserFiles.push_back(Entry);
1798 auto SortedFiles = llvm::concat<InputFileEntry>(std::move(UserFiles),
1799 std::move(SystemFiles));
1801 unsigned UserFilesNum = 0;
1803 std::vector<uint64_t> InputFileOffsets;
1804 for (
const auto &Entry : SortedFiles) {
1805 uint32_t &InputFileID = InputFileIDs[Entry.File];
1806 if (InputFileID != 0)
1810 InputFileOffsets.push_back(Stream.GetCurrentBitNo() - InputFilesOffsetBase);
1812 InputFileID = InputFileOffsets.size();
1814 if (!Entry.IsSystemFile)
1826 if (Name == NameAsRequested)
1829 RecordData::value_type
Record[] = {
1831 InputFileOffsets.size(),
1834 Entry.BufferOverridden,
1838 NameAsRequested.size()};
1840 Stream.EmitRecordWithBlob(IFAbbrevCode,
Record,
1841 (NameAsRequested + Name).str());
1847 Entry.ContentHash[1]};
1848 Stream.EmitRecordWithAbbrev(IFHAbbrevCode,
Record);
1855 auto OffsetsAbbrev = std::make_shared<BitCodeAbbrev>();
1857 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1858 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1860 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1861 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));
1865 InputFileOffsets.size(), UserFilesNum};
1866 Stream.EmitRecordWithBlob(OffsetsAbbrevCode,
Record,
bytes(InputFileOffsets));
1876 using namespace llvm;
1878 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1880 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1881 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1882 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1883 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1885 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1886 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1887 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24));
1888 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1889 return Stream.EmitAbbrev(std::move(Abbrev));
1895 using namespace llvm;
1897 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1899 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1900 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1901 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1902 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1903 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1904 return Stream.EmitAbbrev(std::move(Abbrev));
1911 using namespace llvm;
1913 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1917 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1918 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1919 return Stream.EmitAbbrev(std::move(Abbrev));
1925 using namespace llvm;
1927 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1929 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1930 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1931 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1932 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1933 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1934 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1935 return Stream.EmitAbbrev(std::move(Abbrev));
1940static std::pair<unsigned, unsigned>
1942 llvm::encodeULEB128(KeyLen, Out);
1943 llvm::encodeULEB128(DataLen, Out);
1944 return std::make_pair(KeyLen, DataLen);
1950 class HeaderFileInfoTrait {
1955 llvm::StringMap<unsigned> FrameworkNameOffset;
1958 HeaderFileInfoTrait(
ASTWriter &Writer) : Writer(Writer) {}
1965 using key_type_ref =
const key_type &;
1967 using UnresolvedModule =
1968 llvm::PointerIntPair<Module *, 2, ModuleMap::ModuleHeaderRole>;
1974 : HFI(HFI), AlreadyIncluded(AlreadyIncluded),
1978 bool AlreadyIncluded;
1982 using data_type_ref =
const data_type &;
1991 uint8_t buf[
sizeof(key.Size) +
sizeof(key.ModTime)];
1992 memcpy(buf, &key.Size,
sizeof(key.Size));
1993 memcpy(buf +
sizeof(key.Size), &key.ModTime,
sizeof(key.ModTime));
1994 return llvm::xxh3_64bits(buf);
1997 std::pair<unsigned, unsigned>
1998 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref
Data) {
1999 unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
2001 for (
auto ModInfo :
Data.KnownHeaders)
2004 if (
Data.Unresolved.getPointer())
2009 void EmitKey(raw_ostream& Out, key_type_ref key,
unsigned KeyLen) {
2010 using namespace llvm::support;
2012 endian::Writer
LE(Out, llvm::endianness::little);
2017 Out.write(key.Filename.data(), KeyLen);
2020 void EmitData(raw_ostream &Out, key_type_ref key,
2021 data_type_ref
Data,
unsigned DataLen) {
2022 using namespace llvm::support;
2024 endian::Writer
LE(Out, llvm::endianness::little);
2025 uint64_t Start = Out.tell(); (void)Start;
2027 unsigned char Flags = (
Data.AlreadyIncluded << 6)
2028 | (
Data.HFI.isImport << 5)
2030 Data.HFI.isPragmaOnce << 4)
2031 | (
Data.HFI.DirInfo << 1)
2032 |
Data.HFI.IndexHeaderMapHeader;
2033 LE.write<uint8_t>(Flags);
2035 if (
Data.HFI.LazyControllingMacro.isID())
2041 unsigned Offset = 0;
2042 if (!
Data.HFI.Framework.empty()) {
2044 llvm::StringMap<unsigned>::iterator Pos
2045 = FrameworkNameOffset.find(
Data.HFI.Framework);
2046 if (Pos == FrameworkNameOffset.end()) {
2047 Offset = FrameworkStringData.size() + 1;
2048 FrameworkStringData.append(
Data.HFI.Framework);
2049 FrameworkStringData.push_back(0);
2051 FrameworkNameOffset[
Data.HFI.Framework] = Offset;
2053 Offset = Pos->second;
2055 LE.write<uint32_t>(Offset);
2059 uint32_t
Value = (ModID << 3) | (
unsigned)Role;
2060 assert((
Value >> 3) == ModID &&
"overflow in header module info");
2065 for (
auto ModInfo :
Data.KnownHeaders)
2066 EmitModule(ModInfo.getModule(), ModInfo.getRole());
2067 if (
Data.Unresolved.getPointer())
2068 EmitModule(
Data.Unresolved.getPointer(),
Data.Unresolved.getInt());
2070 assert(Out.tell() - Start == DataLen &&
"Wrong data length");
2073 const char *strings_begin()
const {
return FrameworkStringData.begin(); }
2074 const char *strings_end()
const {
return FrameworkStringData.end(); }
2082void ASTWriter::WriteHeaderSearch(
const HeaderSearch &HS) {
2083 HeaderFileInfoTrait GeneratorTrait(*
this);
2084 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait>
Generator;
2086 unsigned NumHeaderSearchEntries = 0;
2093 if (WritingModule) {
2095 while (!Worklist.empty()) {
2096 Module *M = Worklist.pop_back_val();
2113 if (!
U.Size || (!
U.ModTime && IncludeTimestamps)) {
2114 PP->
Diag(
U.FileNameLoc, diag::err_module_no_size_mtime_for_header)
2122 llvm::sys::path::append(
Filename,
U.FileName);
2125 StringRef FilenameDup = strdup(
Filename.c_str());
2126 SavedStrings.push_back(FilenameDup.data());
2128 HeaderFileInfoTrait::key_type Key = {
2129 FilenameDup, *
U.Size, IncludeTimestamps ? *
U.ModTime : 0};
2130 HeaderFileInfoTrait::data_type
Data = {
2135 ++NumHeaderSearchEntries;
2138 Worklist.append(SubmodulesRange.begin(), SubmodulesRange.end());
2148 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
2167 Filename = StringRef(strdup(FilenameTmp.c_str()));
2168 SavedStrings.push_back(
Filename.data());
2173 HeaderFileInfoTrait::key_type Key = {
2176 HeaderFileInfoTrait::data_type
Data = {
2180 ++NumHeaderSearchEntries;
2185 uint32_t BucketOffset;
2187 using namespace llvm::support;
2189 llvm::raw_svector_ostream Out(TableData);
2191 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
2192 BucketOffset =
Generator.Emit(Out, GeneratorTrait);
2196 using namespace llvm;
2198 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2200 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2201 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2202 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2203 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2204 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2208 NumHeaderSearchEntries, TableData.size()};
2209 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
2210 Stream.EmitRecordWithBlob(TableAbbrev,
Record, TableData);
2213 for (
unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
2214 free(
const_cast<char *
>(SavedStrings[I]));
2217static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
2218 unsigned SLocBufferBlobCompressedAbbrv,
2219 unsigned SLocBufferBlobAbbrv) {
2220 using RecordDataType = ASTWriter::RecordData::value_type;
2225 if (llvm::compression::zstd::isAvailable()) {
2226 llvm::compression::zstd::compress(
2227 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer, 9);
2229 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2230 llvm::toStringRef(CompressedBuffer));
2233 if (llvm::compression::zlib::isAvailable()) {
2234 llvm::compression::zlib::compress(
2235 llvm::arrayRefFromStringRef(Blob.drop_back(1)), CompressedBuffer);
2237 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv,
Record,
2238 llvm::toStringRef(CompressedBuffer));
2243 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv,
Record, Blob);
2254void ASTWriter::WriteSourceManagerBlock(
SourceManager &SourceMgr,
2260 const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo();
2266 unsigned SLocBufferBlobCompressedAbbrv =
2272 std::vector<uint32_t> SLocEntryOffsets;
2273 uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
2279 FileID FID = FileID::get(I);
2283 uint64_t Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;
2284 assert((Offset >> 32) == 0 &&
"SLocEntry offset too large");
2290 if (
Cache->OrigEntry) {
2303 if (!IsSLocAffecting[I])
2305 SLocEntryOffsets.push_back(Offset);
2309 Record.push_back(
File.getFileCharacteristic());
2312 bool EmitBlob =
false;
2315 "Writing to AST an overridden file is not supported");
2318 assert(InputFileIDs[*Content->
OrigEntry] != 0 &&
"Missed file entry");
2321 Record.push_back(getAdjustedNumCreatedFIDs(FID));
2323 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
2324 if (FDI != FileDeclIDs.end()) {
2325 Record.push_back(FDI->second->FirstDeclIndex);
2326 Record.push_back(FDI->second->DeclIDs.size());
2332 Stream.EmitRecordWithAbbrev(SLocFileAbbrv,
Record);
2343 std::optional<llvm::MemoryBufferRef> Buffer =
2345 StringRef Name = Buffer ? Buffer->getBufferIdentifier() :
"";
2346 Stream.EmitRecordWithBlob(SLocBufferAbbrv,
Record,
2347 StringRef(Name.data(), Name.size() + 1));
2354 std::optional<llvm::MemoryBufferRef> Buffer =
2357 Buffer = llvm::MemoryBufferRef(
"<<<INVALID BUFFER>>>",
"");
2358 StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
2359 emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
2360 SLocBufferBlobAbbrv);
2365 SLocEntryOffsets.push_back(Offset);
2381 Record.push_back(getAdjustedOffset(NextOffset - SLoc->
getOffset()) - 1);
2382 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv,
Record);
2388 if (SLocEntryOffsets.empty())
2393 using namespace llvm;
2395 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2397 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2398 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2399 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2400 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2401 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2403 RecordData::value_type
Record[] = {
2406 SLocEntryOffsetsBase - SourceManagerBlockOffset};
2407 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev,
Record,
2408 bytes(SLocEntryOffsets));
2419 llvm::DenseMap<int, int> FilenameMap;
2420 FilenameMap[-1] = -1;
2421 for (
const auto &L : LineTable) {
2424 for (
auto &LE : L.second) {
2425 if (FilenameMap.insert(std::make_pair(
LE.FilenameID,
2426 FilenameMap.size() - 1)).second)
2433 for (
const auto &L : LineTable) {
2441 Record.push_back(L.second.size());
2442 for (
const auto &LE : L.second) {
2445 Record.push_back(FilenameMap[
LE.FilenameID]);
2446 Record.push_back((
unsigned)
LE.FileKind);
2447 Record.push_back(
LE.IncludeOffset);
2462 if (MI->isBuiltinMacro())
2478void ASTWriter::WritePreprocessor(
const Preprocessor &PP,
bool IsModule) {
2479 uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo();
2483 WritePreprocessorDetail(*PPRec, MacroOffsetsBase);
2498 if (AssumeNonNullLoc.
isValid()) {
2512 Record.push_back(SkipInfo->FoundNonSkipPortion);
2513 Record.push_back(SkipInfo->FoundElse);
2520 Record.push_back(Cond.WasSkipping);
2521 Record.push_back(Cond.FoundNonSkip);
2522 Record.push_back(Cond.FoundElse);
2552 if (
Id.second->hadMacroDefinition() &&
2553 (!
Id.second->isFromAST() ||
2554 Id.second->hasChangedSinceDeserialization()))
2555 MacroIdentifiers.push_back(
Id.second);
2558 llvm::sort(MacroIdentifiers, llvm::deref<std::less<>>());
2564 uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2565 assert((StartOffset >> 32) == 0 &&
"Macro identifiers offset too large");
2568 bool EmittedModuleMacros =
false;
2585 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2587 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2588 Record.push_back(VisMD->isPublic());
2590 ModuleMacroRecord.push_back(getSubmoduleID(WritingModule));
2593 ModuleMacroRecord.clear();
2594 EmittedModuleMacros =
true;
2604 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2606 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2607 Record.push_back(VisMD->isPublic());
2614 llvm::DenseMap<ModuleMacro *, unsigned> Visits;
2615 while (!Worklist.empty()) {
2616 auto *
Macro = Worklist.pop_back_val();
2619 ModuleMacroRecord.push_back(getSubmoduleID(
Macro->getOwningModule()));
2621 for (
auto *M :
Macro->overrides())
2622 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));
2625 ModuleMacroRecord.clear();
2628 for (
auto *M :
Macro->overrides())
2629 if (++Visits[M] == M->getNumOverridingMacros())
2630 Worklist.push_back(M);
2632 EmittedModuleMacros =
true;
2635 if (
Record.empty() && !EmittedModuleMacros)
2638 IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2649 std::vector<uint32_t> MacroOffsets;
2651 for (
unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2656 if (ID < FirstMacroID) {
2657 assert(0 &&
"Loaded MacroInfo entered MacroInfosToEmit ?");
2662 unsigned Index =
ID - FirstMacroID;
2663 if (Index >= MacroOffsets.size())
2664 MacroOffsets.resize(Index + 1);
2666 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2667 assert((Offset >> 32) == 0 &&
"Macro offset too large");
2668 MacroOffsets[Index] = Offset;
2695 Stream.EmitRecord(Code,
Record);
2699 for (
unsigned TokNo = 0, e = MI->
getNumTokens(); TokNo != e; ++TokNo) {
2714 using namespace llvm;
2716 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2718 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2719 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2720 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2721 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2723 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2727 MacroOffsetsBase - ASTBlockStartOffset};
2728 Stream.EmitRecordWithBlob(MacroOffsetAbbrev,
Record,
bytes(MacroOffsets));
2733 uint64_t MacroOffsetsBase) {
2743 unsigned NumPreprocessingRecords = 0;
2744 using namespace llvm;
2747 unsigned InclusionAbbrev = 0;
2749 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2751 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2752 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2753 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
2754 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2755 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2756 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2759 unsigned FirstPreprocessorEntityID
2760 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2762 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
2767 (void)++
E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
2770 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2771 assert((Offset >> 32) == 0 &&
"Preprocessed entity offset too large");
2772 SourceRange R = getAdjustedRange((*E)->getSourceRange());
2773 PreprocessedEntityOffsets.emplace_back(
2777 if (
auto *MD = dyn_cast<MacroDefinitionRecord>(*
E)) {
2779 MacroDefinitions[MD] = NextPreprocessorEntityID;
2786 if (
auto *ME = dyn_cast<MacroExpansion>(*
E)) {
2787 Record.push_back(ME->isBuiltinMacro());
2788 if (ME->isBuiltinMacro())
2791 Record.push_back(MacroDefinitions[ME->getDefinition()]);
2796 if (
auto *ID = dyn_cast<InclusionDirective>(*
E)) {
2798 Record.push_back(
ID->getFileName().size());
2799 Record.push_back(
ID->wasInQuotes());
2800 Record.push_back(
static_cast<unsigned>(
ID->getKind()));
2801 Record.push_back(
ID->importedModule());
2803 Buffer +=
ID->getFileName();
2807 Buffer +=
ID->getFile()->getName();
2808 Stream.EmitRecordWithBlob(InclusionAbbrev,
Record, Buffer);
2812 llvm_unreachable(
"Unhandled PreprocessedEntity in ASTWriter");
2817 if (NumPreprocessingRecords > 0) {
2818 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2821 using namespace llvm;
2823 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2825 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2826 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2827 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2830 FirstPreprocessorEntityID -
2832 Stream.EmitRecordWithBlob(PPEOffsetAbbrev,
Record,
2833 bytes(PreprocessedEntityOffsets));
2838 if (SkippedRanges.size() > 0) {
2839 std::vector<PPSkippedRange> SerializedSkippedRanges;
2840 SerializedSkippedRanges.reserve(SkippedRanges.size());
2841 for (
auto const&
Range : SkippedRanges)
2842 SerializedSkippedRanges.emplace_back(
2846 using namespace llvm;
2847 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2849 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2850 unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2854 Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev,
Record,
2855 bytes(SerializedSkippedRanges));
2863 auto Known = SubmoduleIDs.find(Mod);
2864 if (Known != SubmoduleIDs.end())
2865 return Known->second;
2868 if (Top != WritingModule &&
2870 !Top->fullModuleNameIs(StringRef(
getLangOpts().CurrentModule))))
2873 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2876unsigned ASTWriter::getSubmoduleID(
Module *Mod) {
2889 unsigned ChildModules = 0;
2893 return ChildModules + 1;
2896void ASTWriter::WriteSubmodules(
Module *WritingModule) {
2901 using namespace llvm;
2903 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2905 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2906 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2907 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4));
2908 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
2909 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2910 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2911 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2912 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2913 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2914 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2915 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2916 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2917 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2918 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2919 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2920 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2922 Abbrev = std::make_shared<BitCodeAbbrev>();
2924 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2925 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2927 Abbrev = std::make_shared<BitCodeAbbrev>();
2929 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2930 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2932 Abbrev = std::make_shared<BitCodeAbbrev>();
2934 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2935 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2937 Abbrev = std::make_shared<BitCodeAbbrev>();
2939 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2940 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2942 Abbrev = std::make_shared<BitCodeAbbrev>();
2944 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2945 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2946 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2948 Abbrev = std::make_shared<BitCodeAbbrev>();
2950 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2951 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2953 Abbrev = std::make_shared<BitCodeAbbrev>();
2955 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2956 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2958 Abbrev = std::make_shared<BitCodeAbbrev>();
2960 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2961 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2963 Abbrev = std::make_shared<BitCodeAbbrev>();
2965 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2966 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2968 Abbrev = std::make_shared<BitCodeAbbrev>();
2970 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2971 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2972 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2974 Abbrev = std::make_shared<BitCodeAbbrev>();
2976 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2977 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2979 Abbrev = std::make_shared<BitCodeAbbrev>();
2981 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2982 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2983 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2985 Abbrev = std::make_shared<BitCodeAbbrev>();
2987 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2988 unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2991 RecordData::value_type
Record[] = {
2997 std::queue<Module *> Q;
2998 Q.push(WritingModule);
2999 while (!Q.empty()) {
3002 unsigned ID = getSubmoduleID(Mod);
3006 assert(SubmoduleIDs[Mod->
Parent] &&
"Submodule parent not written?");
3007 ParentID = SubmoduleIDs[Mod->
Parent];
3018 (RecordData::value_type)Mod->
Kind,
3030 Stream.EmitRecordWithBlob(DefinitionAbbrev,
Record, Mod->
Name);
3036 Stream.EmitRecordWithBlob(RequiresAbbrev,
Record, R.FeatureName);
3040 if (std::optional<Module::Header> UmbrellaHeader =
3043 Stream.EmitRecordWithBlob(UmbrellaAbbrev,
Record,
3044 UmbrellaHeader->NameAsWritten);
3045 }
else if (std::optional<Module::DirectoryName> UmbrellaDir =
3048 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev,
Record,
3049 UmbrellaDir->NameAsWritten);
3054 unsigned RecordKind;
3065 for (
auto &HL : HeaderLists) {
3066 RecordData::value_type
Record[] = {HL.RecordKind};
3067 for (
auto &H : Mod->
Headers[HL.HeaderKind])
3068 Stream.EmitRecordWithBlob(HL.Abbrev,
Record, H.NameAsWritten);
3077 Stream.EmitRecordWithBlob(TopHeaderAbbrev,
Record, HeaderName);
3085 Record.push_back(getSubmoduleID(I));
3093 Record.push_back(getSubmoduleID(I));
3100 for (
const auto &
E : Mod->
Exports) {
3103 Record.push_back(getSubmoduleID(
E.getPointer()));
3119 Stream.EmitRecordWithBlob(LinkLibraryAbbrev,
Record, LL.Library);
3127 getSubmoduleID(
C.Other)};
3128 Stream.EmitRecordWithBlob(ConflictAbbrev,
Record,
C.Message);
3134 Stream.EmitRecordWithBlob(ConfigMacroAbbrev,
Record, CM);
3159 assert((NextSubmoduleID - FirstSubmoduleID ==
3161 "Wrong # of submodules; found a reference to a non-local, "
3162 "non-imported submodule?");
3167 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
3169 unsigned CurrID = 0;
3172 auto EncodeDiagStateFlags =
3173 [](
const DiagnosticsEngine::DiagState *DS) ->
unsigned {
3176 {(
unsigned)DS->IgnoreAllWarnings, (
unsigned)DS->EnableAllWarnings,
3177 (
unsigned)DS->WarningsAsErrors, (
unsigned)DS->ErrorsAsFatal,
3178 (
unsigned)DS->SuppressSystemWarnings})
3183 unsigned Flags = EncodeDiagStateFlags(
Diag.DiagStatesByLoc.FirstDiagState);
3186 auto AddDiagState = [&](
const DiagnosticsEngine::DiagState *State,
3187 bool IncludeNonPragmaStates) {
3190 assert(Flags == EncodeDiagStateFlags(State) &&
3191 "diag state flags vary in single AST file");
3195 assert(!IncludeNonPragmaStates ||
3196 State ==
Diag.DiagStatesByLoc.FirstDiagState);
3198 unsigned &DiagStateID = DiagStateIDMap[State];
3199 Record.push_back(DiagStateID);
3201 if (DiagStateID == 0) {
3202 DiagStateID = ++CurrID;
3206 auto SizeIdx =
Record.size();
3208 for (
const auto &I : *State) {
3210 if (!I.second.isPragma() && !IncludeNonPragmaStates)
3214 if (!I.second.isPragma() &&
3217 Mappings.push_back(I);
3221 llvm::sort(Mappings, llvm::less_first());
3223 for (
const auto &I : Mappings) {
3224 Record.push_back(I.first);
3225 Record.push_back(I.second.serialize());
3232 AddDiagState(
Diag.DiagStatesByLoc.FirstDiagState, isModule);
3235 auto NumLocationsIdx =
Record.size();
3239 unsigned NumLocations = 0;
3240 for (
auto &FileIDAndFile :
Diag.DiagStatesByLoc.Files) {
3241 if (!FileIDAndFile.first.isValid() ||
3242 !FileIDAndFile.second.HasLocalTransitions)
3248 Record.push_back(FileIDAndFile.second.StateTransitions.size());
3249 for (
auto &StatePoint : FileIDAndFile.second.StateTransitions) {
3250 Record.push_back(getAdjustedOffset(StatePoint.Offset));
3251 AddDiagState(StatePoint.State,
false);
3256 Record[NumLocationsIdx] = NumLocations;
3265 AddDiagState(
Diag.DiagStatesByLoc.CurDiagState,
false);
3278 IdxRef =
TypeIdx(0, NextTypeID++);
3282 assert(Idx.
getValue() >= FirstTypeID &&
"Writing predefined type");
3285 uint64_t Offset = ASTTypeWriter(*this).write(
T) - DeclTypesBlockStartOffset;
3289 if (TypeOffsets.size() == Index)
3290 TypeOffsets.emplace_back(Offset);
3291 else if (TypeOffsets.size() < Index) {
3292 TypeOffsets.resize(Index + 1);
3293 TypeOffsets[Index].set(Offset);
3295 llvm_unreachable(
"Types emitted in wrong order");
3304 auto *ND = dyn_cast<NamedDecl>(
D);
3328 uint64_t Offset = Stream.GetCurrentBitNo();
3330 for (
const auto *
D : DC->
decls()) {
3343 KindDeclPairs.push_back(
D->
getKind());
3344 KindDeclPairs.push_back(
GetDeclRef(
D).getRawValue());
3347 ++NumLexicalDeclContexts;
3349 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev,
Record,
3350 bytes(KindDeclPairs));
3354void ASTWriter::WriteTypeDeclOffsets() {
3355 using namespace llvm;
3358 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3360 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3361 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3362 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3365 Stream.EmitRecordWithBlob(TypeOffsetAbbrev,
Record,
bytes(TypeOffsets));
3369 Abbrev = std::make_shared<BitCodeAbbrev>();
3371 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3372 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3373 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3376 Stream.EmitRecordWithBlob(DeclOffsetAbbrev,
Record,
bytes(DeclOffsets));
3380void ASTWriter::WriteFileDeclIDsMap() {
3381 using namespace llvm;
3384 SortedFileDeclIDs.reserve(FileDeclIDs.size());
3385 for (
const auto &
P : FileDeclIDs)
3386 SortedFileDeclIDs.push_back(std::make_pair(
P.first,
P.second.get()));
3387 llvm::sort(SortedFileDeclIDs, llvm::less_first());
3391 for (
auto &FileDeclEntry : SortedFileDeclIDs) {
3392 DeclIDInFileInfo &Info = *FileDeclEntry.second;
3393 Info.FirstDeclIndex = FileGroupedDeclIDs.size();
3394 llvm::stable_sort(Info.DeclIDs);
3395 for (
auto &LocDeclEntry : Info.DeclIDs)
3396 FileGroupedDeclIDs.push_back(LocDeclEntry.second.getRawValue());
3399 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3401 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3402 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3403 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
3405 FileGroupedDeclIDs.size()};
3406 Stream.EmitRecordWithBlob(AbbrevCode,
Record,
bytes(FileGroupedDeclIDs));
3409void ASTWriter::WriteComments() {
3411 auto _ = llvm::make_scope_exit([
this] { Stream.ExitBlock(); });
3422 for (
const auto &FO : Context->
Comments.OrderedComments) {
3423 for (
const auto &OC : FO.second) {
3442class ASTMethodPoolTrait {
3447 using key_type_ref = key_type;
3453 using data_type_ref =
const data_type &;
3458 explicit ASTMethodPoolTrait(
ASTWriter &Writer) : Writer(Writer) {}
3464 std::pair<unsigned, unsigned>
3465 EmitKeyDataLength(raw_ostream& Out,
Selector Sel,
3466 data_type_ref Methods) {
3470 unsigned DataLen = 4 + 2 + 2;
3473 if (ShouldWriteMethodListNode(Method))
3474 DataLen +=
sizeof(
DeclID);
3477 if (ShouldWriteMethodListNode(Method))
3478 DataLen +=
sizeof(
DeclID);
3482 void EmitKey(raw_ostream& Out,
Selector Sel,
unsigned) {
3483 using namespace llvm::support;
3485 endian::Writer
LE(Out, llvm::endianness::little);
3487 assert((Start >> 32) == 0 &&
"Selector key offset too large");
3490 LE.write<uint16_t>(N);
3493 for (
unsigned I = 0; I != N; ++I)
3498 void EmitData(raw_ostream& Out, key_type_ref,
3499 data_type_ref Methods,
unsigned DataLen) {
3500 using namespace llvm::support;
3502 endian::Writer
LE(Out, llvm::endianness::little);
3503 uint64_t Start = Out.tell(); (void)Start;
3504 LE.write<uint32_t>(Methods.ID);
3505 unsigned NumInstanceMethods = 0;
3508 if (ShouldWriteMethodListNode(Method))
3509 ++NumInstanceMethods;
3511 unsigned NumFactoryMethods = 0;
3514 if (ShouldWriteMethodListNode(Method))
3515 ++NumFactoryMethods;
3517 unsigned InstanceBits = Methods.Instance.getBits();
3518 assert(InstanceBits < 4);
3519 unsigned InstanceHasMoreThanOneDeclBit =
3520 Methods.Instance.hasMoreThanOneDecl();
3521 unsigned FullInstanceBits = (NumInstanceMethods << 3) |
3522 (InstanceHasMoreThanOneDeclBit << 2) |
3524 unsigned FactoryBits = Methods.Factory.getBits();
3525 assert(FactoryBits < 4);
3526 unsigned FactoryHasMoreThanOneDeclBit =
3527 Methods.Factory.hasMoreThanOneDecl();
3528 unsigned FullFactoryBits = (NumFactoryMethods << 3) |
3529 (FactoryHasMoreThanOneDeclBit << 2) |
3531 LE.write<uint16_t>(FullInstanceBits);
3532 LE.write<uint16_t>(FullFactoryBits);
3535 if (ShouldWriteMethodListNode(Method))
3539 if (ShouldWriteMethodListNode(Method))
3542 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
3547 return (
Node->getMethod() && !
Node->getMethod()->isFromASTFile());
3558void ASTWriter::WriteSelectors(
Sema &SemaRef) {
3559 using namespace llvm;
3564 unsigned NumTableEntries = 0;
3567 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait>
Generator;
3568 ASTMethodPoolTrait Trait(*
this);
3572 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
3573 for (
auto &SelectorAndID : SelectorIDs) {
3578 ASTMethodPoolTrait::data_type
Data = {
3584 Data.Instance = F->second.first;
3585 Data.Factory = F->second.second;
3589 if (Chain && ID < FirstSelectorID) {
3591 bool changed =
false;
3594 if (!M->getMethod()->isFromASTFile()) {
3602 if (!M->getMethod()->isFromASTFile()) {
3610 }
else if (
Data.Instance.getMethod() ||
Data.Factory.getMethod()) {
3619 uint32_t BucketOffset;
3621 using namespace llvm::support;
3623 ASTMethodPoolTrait Trait(*
this);
3624 llvm::raw_svector_ostream Out(MethodPool);
3626 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3627 BucketOffset =
Generator.Emit(Out, Trait);
3631 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3633 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3634 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3635 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3636 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3642 Stream.EmitRecordWithBlob(MethodPoolAbbrev,
Record, MethodPool);
3646 Abbrev = std::make_shared<BitCodeAbbrev>();
3648 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3649 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3650 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3651 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3655 RecordData::value_type
Record[] = {
3658 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev,
Record,
3659 bytes(SelectorOffsets));
3665void ASTWriter::WriteReferencedSelectorsPool(
Sema &SemaRef) {
3666 using namespace llvm;
3678 Selector Sel = SelectorAndLocation.first;
3680 Writer.AddSelectorRef(Sel);
3702 for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
3704 if (!Redecl->isFromASTFile()) {
3708 if (!Redecl->getDeclContext()->getRedeclContext()->Equals(
3711 return cast<NamedDecl>(Redecl);
3716 if (Redecl->getOwningModuleID() == 0)
3721 if (!
First->isFromASTFile())
3722 return cast<NamedDecl>(
First);
3732bool IsInterestingIdentifier(
const IdentifierInfo *II, uint64_t MacroOffset,
3733 bool IsModule,
bool IsCPlusPlus) {
3734 bool NeedDecls = !IsModule || !IsCPlusPlus;
3736 bool IsInteresting =
3740 if (MacroOffset || II->
isPoisoned() || (!IsModule && IsInteresting) ||
3751 bool IsCPlusPlus = Writer.
getLangOpts().CPlusPlus;
3752 return IsInterestingIdentifier(II, 0, IsModule, IsCPlusPlus);
3755class ASTIdentifierTableTrait {
3768 return IsInterestingIdentifier(II, MacroOffset, IsModule,
3774 using key_type_ref = key_type;
3777 using data_type_ref = data_type;
3785 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule),
3786 NeedDecls(!IsModule || !Writer.getLangOpts().
CPlusPlus),
3787 InterestingIdentifierOffsets(InterestingIdentifierOffsets) {}
3789 bool needDecls()
const {
return NeedDecls; }
3792 return llvm::djbHash(II->
getName());
3800 std::pair<unsigned, unsigned>
3810 if (InterestingIdentifierOffsets &&
3812 InterestingIdentifierOffsets->push_back(Out.tell());
3823 DataLen += std::distance(IdResolver.
begin(II), IdResolver.
end()) *
3829 void EmitKey(raw_ostream &Out,
const IdentifierInfo *II,
unsigned KeyLen) {
3835 using namespace llvm::support;
3837 endian::Writer
LE(Out, llvm::endianness::little);
3847 assert((Bits & 0xffff) == Bits &&
"ObjCOrBuiltinID too big for ASTReader.");
3848 LE.write<uint16_t>(Bits);
3850 bool HadMacroDefinition = MacroOffset != 0;
3851 Bits = (Bits << 1) |
unsigned(HadMacroDefinition);
3853 Bits = (Bits << 1) |
unsigned(II->
isPoisoned());
3856 LE.write<uint16_t>(Bits);
3858 if (HadMacroDefinition)
3859 LE.write<uint32_t>(MacroOffset);
3890 using namespace llvm;
3897 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait>
Generator;
3898 ASTIdentifierTableTrait Trait(*
this, PP, IdResolver, IsModule,
3899 IsModule ? &InterestingIdents :
nullptr);
3903 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
3904 for (
auto IdentIDPair : IdentifierIDs) {
3907 assert(II &&
"NULL identifier in identifier table");
3912 (Trait.needDecls() &&
3919 uint32_t BucketOffset;
3921 using namespace llvm::support;
3925 endian::write<uint32_t>(Out, 0, llvm::endianness::little);
3926 BucketOffset =
Generator.Emit(Out, Trait);
3930 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3932 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3933 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3934 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3942 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3944 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3945 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3946 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3949 for (
unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
3950 assert(IdentifierOffsets[I] &&
"Missing identifier offset?");
3954 IdentifierOffsets.size()};
3955 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev,
Record,
3956 bytes(IdentifierOffsets));
3960 if (!InterestingIdents.empty())
3971class ASTDeclContextNameLookupTrait {
3977 using key_type_ref = key_type;
3980 using data_type = std::pair<unsigned, unsigned>;
3981 using data_type_ref =
const data_type &;
3986 explicit ASTDeclContextNameLookupTrait(
ASTWriter &Writer) : Writer(Writer) {}
3988 template<
typename Coll>
3989 data_type getData(
const Coll &Decls) {
3990 unsigned Start = DeclIDs.size();
4006 DeclIDs.push_back(Writer.
GetDeclRef(DeclForLocalLookup));
4008 return std::make_pair(Start, DeclIDs.size());
4012 unsigned Start = DeclIDs.size();
4017 return std::make_pair(Start, DeclIDs.size());
4020 static bool EqualKey(key_type_ref a, key_type_ref
b) {
4025 return Name.getHash();
4028 void EmitFileRef(raw_ostream &Out,
ModuleFile *F)
const {
4030 "have reference to loaded module file but no chain?");
4032 using namespace llvm::support;
4035 llvm::endianness::little);
4038 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
4040 data_type_ref Lookup) {
4041 unsigned KeyLen = 1;
4042 switch (Name.getKind()) {
4064 unsigned DataLen =
sizeof(
DeclID) * (Lookup.second - Lookup.first);
4070 using namespace llvm::support;
4072 endian::Writer
LE(Out, llvm::endianness::little);
4073 LE.write<uint8_t>(Name.getKind());
4074 switch (Name.getKind()) {
4087 "Invalid operator?");
4088 LE.write<uint8_t>(Name.getOperatorKind());
4097 llvm_unreachable(
"Invalid name kind?");
4100 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
4102 using namespace llvm::support;
4104 endian::Writer
LE(Out, llvm::endianness::little);
4105 uint64_t Start = Out.tell(); (void)Start;
4106 for (
unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
4108 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
4116 return Result.hasExternalDecls() &&
4117 DC->hasNeedToReconcileExternalVisibleStorage();
4126 for (
auto *
D :
Result.getLookupResult()) {
4128 if (LocalD->isFromASTFile())
4147ASTWriter::GenerateNameLookupTable(
const DeclContext *ConstDC,
4149 assert(!ConstDC->hasLazyLocalLexicalLookups() &&
4150 !ConstDC->hasLazyExternalLexicalLookups() &&
4151 "must call buildLookups first");
4159 ASTDeclContextNameLookupTrait>
Generator;
4160 ASTDeclContextNameLookupTrait Trait(*
this);
4172 auto &Name = Lookup.first;
4173 auto &
Result = Lookup.second;
4188 if ((GeneratingReducedBMI || isLookupResultExternal(
Result, DC)) &&
4206 if (Lookup.second.getLookupResult().empty())
4209 switch (Lookup.first.getNameKind()) {
4211 Names.push_back(Lookup.first);
4215 assert(isa<CXXRecordDecl>(DC) &&
4216 "Cannot have a constructor name outside of a class!");
4217 ConstructorNameSet.insert(Name);
4221 assert(isa<CXXRecordDecl>(DC) &&
4222 "Cannot have a conversion function name outside of a class!");
4223 ConversionNameSet.insert(Name);
4231 if (
auto *
D = dyn_cast<CXXRecordDecl>(DC)) {
4245 if (ConstructorNameSet.erase(ImplicitCtorName))
4246 Names.push_back(ImplicitCtorName);
4251 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty())
4252 for (
Decl *ChildD : cast<CXXRecordDecl>(DC)->decls())
4253 if (
auto *ChildND = dyn_cast<NamedDecl>(ChildD)) {
4254 auto Name = ChildND->getDeclName();
4255 switch (Name.getNameKind()) {
4260 if (ConstructorNameSet.erase(Name))
4261 Names.push_back(Name);
4265 if (ConversionNameSet.erase(Name))
4266 Names.push_back(Name);
4270 if (ConstructorNameSet.empty() && ConversionNameSet.empty())
4274 assert(ConstructorNameSet.empty() &&
"Failed to find all of the visible "
4275 "constructors by walking all the "
4276 "lexical members of the context.");
4277 assert(ConversionNameSet.empty() &&
"Failed to find all of the visible "
4278 "conversion functions by walking all "
4279 "the lexical members of the context.");
4286 for (
auto &Name : Names)
4298 for (
auto &Name : Names) {
4301 switch (Name.getNameKind()) {
4319 if (!ConstructorDecls.empty())
4320 Generator.insert(ConstructorDecls.front()->getDeclName(),
4321 Trait.getData(ConstructorDecls), Trait);
4322 if (!ConversionDecls.empty())
4323 Generator.insert(ConversionDecls.front()->getDeclName(),
4324 Trait.getData(ConversionDecls), Trait);
4329 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table :
nullptr);
4342 if (isa<NamespaceDecl>(DC) && Chain &&
4345 for (
auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;
4346 Prev = Prev->getPreviousDecl())
4347 if (!Prev->isFromASTFile())
4360 LookupResults.reserve(Map->size());
4361 for (
auto &Entry : *Map)
4362 LookupResults.push_back(
4363 std::make_pair(Entry.first, Entry.second.getLookupResult()));
4366 llvm::sort(LookupResults, llvm::less_first());
4367 for (
auto &NameAndResult : LookupResults) {
4375 assert(
Result.empty() &&
"Cannot have a constructor or conversion "
4376 "function name in a namespace!");
4381 if (ND->isFromASTFile())
4389 if (GeneratingReducedBMI && !ND->isFromExplicitGlobalModule() &&
4417 uint64_t Offset = Stream.GetCurrentBitNo();
4419 if (!Map || Map->empty())
4424 GenerateNameLookupTable(DC, LookupTable);
4428 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev,
Record,
4430 ++NumVisibleDeclContexts;
4440void ASTWriter::WriteDeclContextVisibleUpdate(
const DeclContext *DC) {
4442 if (!Map || Map->empty())
4447 GenerateNameLookupTable(DC, LookupTable);
4451 if (isa<NamespaceDecl>(DC))
4457 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev,
Record, LookupTable);
4467void ASTWriter::WriteOpenCLExtensions(
Sema &SemaRef) {
4473 for (
const auto &I:Opts.OptMap) {
4475 auto V = I.getValue();
4476 Record.push_back(
V.Supported ? 1 : 0);
4477 Record.push_back(
V.Enabled ? 1 : 0);
4478 Record.push_back(
V.WithPragma ? 1 : 0);
4485void ASTWriter::WriteCUDAPragmas(
Sema &SemaRef) {
4486 if (SemaRef.
CUDA().ForceHostDeviceDepth > 0) {
4487 RecordData::value_type
Record[] = {SemaRef.
CUDA().ForceHostDeviceDepth};
4492void ASTWriter::WriteObjCCategories() {
4496 for (
unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
4498 unsigned StartIndex = Categories.size();
4503 Categories.push_back(0);
4507 Cat =
Class->known_categories_begin(),
4508 CatEnd =
Class->known_categories_end();
4509 Cat != CatEnd; ++Cat, ++Size) {
4515 Categories[StartIndex] =
Size;
4519 CategoriesMap.push_back(CatInfo);
4524 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
4527 using namespace llvm;
4529 auto Abbrev = std::make_shared<BitCodeAbbrev>();
4531 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
4532 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4533 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
4536 Stream.EmitRecordWithBlob(AbbrevID,
Record,
4537 reinterpret_cast<char *
>(CategoriesMap.data()),
4544void ASTWriter::WriteLateParsedTemplates(
Sema &SemaRef) {
4551 for (
auto &LPTMapEntry : LPTMap) {
4559 for (
const auto &Tok : LPT.
Toks) {
4567void ASTWriter::WriteOptimizePragmaOptions(
Sema &SemaRef) {
4575void ASTWriter::WriteMSStructPragmaOptions(
Sema &SemaRef) {
4583void ASTWriter::WriteMSPointersToMembersPragmaOptions(
Sema &SemaRef) {
4591void ASTWriter::WritePackPragmaOptions(
Sema &SemaRef) {
4611void ASTWriter::WriteFloatControlPragmaOptions(
Sema &SemaRef) {
4621 for (
const auto &StackEntry : SemaRef.
FpPragmaStack.Stack) {
4622 Record.push_back(StackEntry.Value.getAsOpaqueInt());
4630void ASTWriter::WriteModuleFileExtension(
Sema &SemaRef,
4636 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
4638 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4639 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4640 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4641 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4642 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4643 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv));
4649 Record.push_back(Metadata.MajorVersion);
4650 Record.push_back(Metadata.MinorVersion);
4651 Record.push_back(Metadata.BlockName.size());
4652 Record.push_back(Metadata.UserInfo.size());
4654 Buffer += Metadata.BlockName;
4655 Buffer += Metadata.UserInfo;
4656 Stream.EmitRecordWithBlob(Abbrev,
Record, Buffer);
4674 if (!A || (isa<PreferredNameAttr>(A) &&
4675 Writer->isWritingStdCXXNamedModules()))
4676 return Record.push_back(0);
4686 Record.push_back(A->getAttributeSpellingListIndexRaw());
4689#include "clang/Serialization/AttrPCHWrite.inc"
4695 for (
const auto *A : Attrs)
4709 case tok::annot_pragma_loop_hint: {
4713 Record.push_back(Info->Toks.size());
4714 for (
const auto &
T : Info->Toks)
4718 case tok::annot_pragma_pack: {
4721 Record.push_back(
static_cast<unsigned>(Info->Action));
4727 case tok::annot_pragma_openmp:
4728 case tok::annot_pragma_openmp_end:
4729 case tok::annot_pragma_unused:
4730 case tok::annot_pragma_openacc:
4731 case tok::annot_pragma_openacc_end:
4734 llvm_unreachable(
"missing serialization code for annotation token");
4745 Record.push_back(Str.size());
4750 assert(Context &&
"should have context when outputting path");
4753 StringRef PathStr(
Path.data(),
Path.size());
4754 if (PathStr ==
"<built-in>" || PathStr ==
"<command line>")
4761 const char *PathBegin =
Path.data();
4762 const char *PathPtr =
4764 if (PathPtr != PathBegin) {
4765 Path.erase(
Path.begin(),
Path.begin() + (PathPtr - PathBegin));
4782 Stream.EmitRecordWithBlob(Abbrev,
Record, FilePath);
4787 Record.push_back(Version.getMajor());
4788 if (std::optional<unsigned> Minor = Version.getMinor())
4789 Record.push_back(*Minor + 1);
4792 if (std::optional<unsigned> Subminor = Version.getSubminor())
4793 Record.push_back(*Subminor + 1);
4811 assert(ID < IdentifierOffsets.size());
4812 IdentifierOffsets[ID] = Offset;
4818 unsigned ID = SelectorIDs[Sel];
4819 assert(ID &&
"Unknown selector");
4822 if (ID < FirstSelectorID)
4824 SelectorOffsets[ID - FirstSelectorID] = Offset;
4830 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
4831 bool IncludeTimestamps,
bool BuildingImplicitModule,
4832 bool GeneratingReducedBMI)
4833 : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),
4834 IncludeTimestamps(IncludeTimestamps),
4835 BuildingImplicitModule(BuildingImplicitModule),
4836 GeneratingReducedBMI(GeneratingReducedBMI) {
4837 for (
const auto &Ext : Extensions) {
4838 if (
auto Writer = Ext->createExtensionWriter(*
this))
4839 ModuleFileExtensionWriters.push_back(std::move(Writer));
4846 assert(WritingAST &&
"can't determine lang opts when not writing AST");
4851 return IncludeTimestamps ?
E->getModificationTime() : 0;
4855 Module *WritingModule, StringRef isysroot,
4856 bool ShouldCacheASTInMemory) {
4857 llvm::TimeTraceScope scope(
"WriteAST", OutputFile);
4860 ASTHasCompilerErrors =
4864 Stream.Emit((
unsigned)
'C', 8);
4865 Stream.Emit((
unsigned)
'P', 8);
4866 Stream.Emit((
unsigned)
'C', 8);
4867 Stream.Emit((
unsigned)
'H', 8);
4869 WriteBlockInfoBlock();
4873 this->WritingModule = WritingModule;
4874 ASTFileSignature Signature = WriteASTCore(SemaRef, isysroot, WritingModule);
4877 this->WritingModule =
nullptr;
4878 this->BaseDirectory.clear();
4881 if (ShouldCacheASTInMemory) {
4884 llvm::MemoryBuffer::getMemBufferCopy(
4885 StringRef(Buffer.begin(), Buffer.size())));
4890template<
typename Vector>
4892 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true),
E = Vec.end();
4898template <
typename Vector>
4901 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true),
E = Vec.end();
4907void ASTWriter::computeNonAffectingInputFiles() {
4911 IsSLocAffecting.resize(N,
true);
4916 auto AffectingModuleMaps = GetAffectingModuleMaps(*PP, WritingModule);
4918 unsigned FileIDAdjustment = 0;
4919 unsigned OffsetAdjustment = 0;
4921 NonAffectingFileIDAdjustments.reserve(N);
4922 NonAffectingOffsetAdjustments.reserve(N);
4924 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
4925 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
4927 for (
unsigned I = 1; I != N; ++I) {
4929 FileID FID = FileID::get(I);
4936 if (!
Cache->OrigEntry)
4944 if (!AffectingModuleMaps)
4948 if (llvm::is_contained(*AffectingModuleMaps, *
Cache->OrigEntry))
4951 IsSLocAffecting[I] =
false;
4953 FileIDAdjustment += 1;
4959 if (!NonAffectingFileIDs.empty() &&
4960 NonAffectingFileIDs.back().ID == FID.ID - 1) {
4961 NonAffectingFileIDs.back() = FID;
4963 NonAffectingFileIDAdjustments.back() = FileIDAdjustment;
4964 NonAffectingOffsetAdjustments.back() = OffsetAdjustment;
4968 NonAffectingFileIDs.push_back(FID);
4971 NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);
4972 NonAffectingOffsetAdjustments.push_back(OffsetAdjustment);
4981 for (StringRef
Path :
4984 for (
unsigned I = 1; I != N; ++I) {
4985 if (IsSLocAffecting[I]) {
4991 if (!
Cache->OrigEntry)
4994 Cache->OrigEntry->getNameAsRequested());
5000void ASTWriter::PrepareWritingSpecialDecls(
Sema &SemaRef) {
5003 bool isModule = WritingModule !=
nullptr;
5010 PredefinedDecls.insert(
D);
5018 RegisterPredefDecl(Context.ObjCProtocolClassDecl,
5022 RegisterPredefDecl(Context.ObjCInstanceTypeDecl,
5026 RegisterPredefDecl(Context.BuiltinMSVaListDecl,
5031 RegisterPredefDecl(Context.MakeIntegerSeqDecl,
5033 RegisterPredefDecl(Context.CFConstantStringTypeDecl,
5035 RegisterPredefDecl(Context.CFConstantStringTagDecl,
5037 RegisterPredefDecl(Context.TypePackElementDecl,
5050 if (GeneratingReducedBMI) {
5076 if (GeneratingReducedBMI)
5099 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I)
5110 "There are local ones at end of translation unit!");
5123 for (
const auto &I : SemaRef.KnownNamespaces)
5130 for (
const auto &I : Undefined)
5136 for (
const auto &DeleteExprsInfo :
5143 for (
const auto *I : DeclsToEmitEvenIfUnreferenced)
5145 DeclsToEmitEvenIfUnreferenced.clear();
5157 llvm::sort(IIs, llvm::deref<std::less<>>());
5164 for (
auto *
D : SemaRef.DeclsToCheckForDeferredDiags)
5168void ASTWriter::WriteSpecialDeclRecords(
Sema &SemaRef) {
5171 bool isModule = WritingModule !=
nullptr;
5174 if (!EagerlyDeserializedDecls.empty())
5177 if (!ModularCodegenDecls.empty())
5183 TentativeDefinitions);
5184 if (!TentativeDefinitions.empty())
5191 UnusedFileScopedDecls);
5192 if (!UnusedFileScopedDecls.empty())
5198 if (!ExtVectorDecls.empty())
5204 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I) {
5220 if (!UnusedLocalTypedefNameCandidates.empty())
5222 UnusedLocalTypedefNameCandidates);
5233 if (!PendingInstantiations.empty())
5239 auto AddEmittedDeclRefOrZero = [
this, &SemaDeclRefs](
Decl *
D) {
5241 SemaDeclRefs.push_back(0);
5250 if (!SemaDeclRefs.empty())
5255 for (
auto *
D : SemaRef.DeclsToCheckForDeferredDiags)
5258 if (!DeclsToCheckForDeferredDiags.empty())
5260 DeclsToCheckForDeferredDiags);
5266 AddDeclRef(CudaCallDecl, CUDASpecialDeclRefs);
5274 DelegatingCtorDecls);
5275 if (!DelegatingCtorDecls.empty())
5280 for (
const auto &I : SemaRef.KnownNamespaces) {
5284 if (!KnownNamespaces.empty())
5291 for (
const auto &I : Undefined) {
5298 if (!UndefinedButUsed.empty())
5305 for (
const auto &DeleteExprsInfo :
5310 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze);
5311 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());
5312 for (
const auto &DeleteLoc : DeleteExprsInfo.second) {
5314 DeleteExprsToAnalyze.push_back(DeleteLoc.second);
5318 if (!DeleteExprsToAnalyze.empty())
5324 using namespace llvm;
5326 bool isModule = WritingModule !=
nullptr;
5337 computeNonAffectingInputFiles();
5339 writeUnhashedControlBlock(PP, Context);
5352 IdentifierIDs.clear();
5365 if (IsInterestingNonMacroIdentifier(
ID.second, *
this))
5366 IIs.push_back(
ID.second);
5369 llvm::sort(IIs, llvm::deref<std::less<>>());
5377 for (
const auto &WeakUndeclaredIdentifierList :
5379 const IdentifierInfo *
const II = WeakUndeclaredIdentifierList.first;
5380 for (
const auto &WI : WeakUndeclaredIdentifierList.second) {
5393 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
5394 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
5395 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
5398 PrepareWritingSpecialDecls(SemaRef);
5401 WriteControlBlock(PP, Context, isysroot);
5404 Stream.FlushToWord();
5405 ASTBlockRange.first = Stream.GetCurrentBitNo() >> 3;
5407 ASTBlockStartOffset = Stream.GetCurrentBitNo();
5424 for (
auto &SelectorAndID : SelectorIDs)
5425 AllSelectors.push_back(SelectorAndID.first);
5426 for (
auto &
Selector : AllSelectors)
5449 auto Abbrev = std::make_shared<BitCodeAbbrev>();
5451 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
5452 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
5455 llvm::raw_svector_ostream Out(Buffer);
5457 using namespace llvm::support;
5459 endian::Writer
LE(Out, llvm::endianness::little);
5460 LE.write<uint8_t>(
static_cast<uint8_t
>(M.
Kind));
5462 LE.write<uint16_t>(Name.size());
5463 Out.write(Name.data(), Name.size());
5467 uint32_t
None = std::numeric_limits<uint32_t>::max();
5469 auto writeBaseIDOrNone = [&](
auto BaseID,
bool ShouldWrite) {
5470 assert(BaseID < std::numeric_limits<uint32_t>::max() &&
"base id too high");
5472 LE.write<uint32_t>(BaseID);
5474 LE.write<uint32_t>(
None);
5487 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev,
Record,
5488 Buffer.data(), Buffer.size());
5491 WriteDeclAndTypes(Context);
5493 WriteFileDeclIDsMap();
5496 WritePreprocessor(PP, isModule);
5498 WriteSelectors(SemaRef);
5499 WriteReferencedSelectorsPool(SemaRef);
5500 WriteLateParsedTemplates(SemaRef);
5501 WriteIdentifierTable(PP, SemaRef.
IdResolver, isModule);
5503 WriteOpenCLExtensions(SemaRef);
5504 WriteCUDAPragmas(SemaRef);
5508 WriteSubmodules(WritingModule);
5512 WriteSpecialDeclRecords(SemaRef);
5515 if (!WeakUndeclaredIdentifiers.empty())
5517 WeakUndeclaredIdentifiers);
5519 if (!WritingModule) {
5528 assert(SubmoduleIDs.contains(I->getImportedModule()));
5529 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
5530 I->getImportedModule()));
5533 if (!Imports.empty()) {
5534 auto Cmp = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5537 auto Eq = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5538 return A.ID == B.ID;
5542 llvm::sort(Imports, Cmp);
5543 Imports.erase(std::unique(Imports.begin(), Imports.end(),
Eq),
5547 for (
const auto &Import : Imports) {
5548 ImportedModules.push_back(
Import.ID);
5559 WriteObjCCategories();
5560 if(!WritingModule) {
5561 WriteOptimizePragmaOptions(SemaRef);
5562 WriteMSStructPragmaOptions(SemaRef);
5563 WriteMSPointersToMembersPragmaOptions(SemaRef);
5565 WritePackPragmaOptions(SemaRef);
5566 WriteFloatControlPragmaOptions(SemaRef);
5569 RecordData::value_type
Record[] = {
5570 NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts};
5573 Stream.FlushToWord();
5574 ASTBlockRange.second = Stream.GetCurrentBitNo() >> 3;
5577 for (
const auto &ExtWriter : ModuleFileExtensionWriters)
5578 WriteModuleFileExtension(SemaRef, *ExtWriter);
5580 return backpatchSignature();
5583void ASTWriter::EnteringModulePurview() {
5586 if (GeneratingReducedBMI)
5587 DeclUpdatesFromGMF.swap(DeclUpdates);
5593void ASTWriter::AddedManglingNumber(
const Decl *
D,
unsigned Number) {
5599void ASTWriter::AddedStaticLocalNumbers(
const Decl *
D,
unsigned Number) {
5618void ASTWriter::WriteDeclAndTypes(
ASTContext &Context) {
5623 DeclTypesBlockStartOffset = Stream.GetCurrentBitNo();
5627 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord);
5628 while (!DeclTypesToEmit.empty()) {
5629 DeclOrType DOT = DeclTypesToEmit.front();
5630 DeclTypesToEmit.pop();
5632 WriteType(DOT.getType());
5634 WriteDecl(Context, DOT.getDecl());
5636 }
while (!DeclUpdates.empty());
5638 DoneWritingDeclsAndTypes =
true;
5642 assert(DelayedNamespace.empty() || GeneratingReducedBMI);
5645 uint64_t LexicalOffset = WriteDeclContextLexicalBlock(Context, NS);
5646 uint64_t VisibleOffset = WriteDeclContextVisibleBlock(Context, NS);
5650 LexicalOffset -= DeclTypesBlockStartOffset;
5653 VisibleOffset -= DeclTypesBlockStartOffset;
5656 DelayedNamespaceRecord.push_back(LexicalOffset);
5657 DelayedNamespaceRecord.push_back(VisibleOffset);
5662 assert(DeclTypesToEmit.empty());
5663 assert(DeclUpdates.empty());
5668 WriteTypeDeclOffsets();
5669 if (!DeclUpdatesOffsetsRecord.empty())
5672 if (!DelayedNamespaceRecord.empty())
5674 DelayedNamespaceRecord);
5688 NewGlobalKindDeclPairs.push_back(
D->
getKind());
5689 NewGlobalKindDeclPairs.push_back(
GetDeclRef(
D).getRawValue());
5692 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
5694 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
5695 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
5698 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev,
Record,
5699 bytes(NewGlobalKindDeclPairs));
5701 Abv = std::make_shared<llvm::BitCodeAbbrev>();
5703 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
5704 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
5705 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));
5708 WriteDeclContextVisibleUpdate(TU);
5711 if (Context.ExternCContext)
5712 WriteDeclContextVisibleUpdate(Context.ExternCContext);
5715 for (
auto *DC : UpdatedDeclContexts)
5716 WriteDeclContextVisibleUpdate(DC);
5719void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
5720 if (DeclUpdates.empty())
5723 DeclUpdateMap LocalUpdates;
5724 LocalUpdates.swap(DeclUpdates);
5726 for (
auto &DeclUpdate : LocalUpdates) {
5727 const Decl *
D = DeclUpdate.first;
5729 bool HasUpdatedBody =
false;
5730 bool HasAddedVarDefinition =
false;
5733 for (
auto &
Update : DeclUpdate.second) {
5739 HasUpdatedBody =
true;
5741 HasAddedVarDefinition =
true;
5749 assert(
Update.getDecl() &&
"no decl to add?");
5764 cast<ParmVarDecl>(
Update.getDecl())->getDefaultArg());
5769 cast<FieldDecl>(
Update.getDecl())->getInClassInitializer());
5773 auto *RD = cast<CXXRecordDecl>(
D);
5774 UpdatedDeclContexts.insert(RD->getPrimaryContext());
5775 Record.push_back(RD->isParamDestroyedInCallee());
5776 Record.push_back(llvm::to_underlying(RD->getArgPassingRestrictions()));
5777 Record.AddCXXDefinitionData(RD);
5778 Record.AddOffset(WriteDeclContextLexicalBlock(*Context, RD));
5783 if (
auto *MSInfo = RD->getMemberSpecializationInfo()) {
5784 Record.push_back(MSInfo->getTemplateSpecializationKind());
5785 Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
5787 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
5788 Record.push_back(Spec->getTemplateSpecializationKind());
5789 Record.AddSourceLocation(Spec->getPointOfInstantiation());
5793 auto From = Spec->getInstantiatedFrom();
5794 if (
auto PartialSpec =
5797 Record.AddDeclRef(PartialSpec);
5798 Record.AddTemplateArgumentList(
5799 &Spec->getTemplateInstantiationArgs());
5804 Record.push_back(llvm::to_underlying(RD->getTagKind()));
5805 Record.AddSourceLocation(RD->getLocation());
5806 Record.AddSourceLocation(RD->getBeginLoc());
5807 Record.AddSourceRange(RD->getBraceRange());
5820 Record.AddStmt(cast<CXXDestructorDecl>(
D)->getOperatorDeleteThisArg());
5826 Record.writeExceptionSpecInfo(prototype->getExceptionSpecInfo());
5844 D->
getAttr<OMPThreadPrivateDeclAttr>()->getRange());
5848 auto *A =
D->
getAttr<OMPAllocateDeclAttr>();
5849 Record.push_back(A->getAllocatorType());
5850 Record.AddStmt(A->getAllocator());
5851 Record.AddStmt(A->getAlignment());
5852 Record.AddSourceRange(A->getRange());
5857 Record.push_back(
D->
getAttr<OMPDeclareTargetDeclAttr>()->getMapType());
5859 D->
getAttr<OMPDeclareTargetDeclAttr>()->getRange());
5875 if (HasUpdatedBody) {
5876 const auto *Def = cast<FunctionDecl>(
D);
5878 Record.push_back(Def->isInlined());
5879 Record.AddSourceLocation(Def->getInnerLocStart());
5880 Record.AddFunctionDefinition(Def);
5881 }
else if (HasAddedVarDefinition) {
5882 const auto *VD = cast<VarDecl>(
D);
5884 Record.push_back(VD->isInline());
5885 Record.push_back(VD->isInlineSpecified());
5886 Record.AddVarDeclInit(VD);
5903 NonAffectingFileIDs.empty())
5905 auto It = llvm::lower_bound(NonAffectingFileIDs, FID);
5906 unsigned Idx = std::distance(NonAffectingFileIDs.begin(), It);
5907 unsigned Offset = NonAffectingFileIDAdjustments[Idx];
5908 return FileID::get(FID.getOpaqueValue() - Offset);
5911unsigned ASTWriter::getAdjustedNumCreatedFIDs(
FileID FID)
const {
5917 unsigned AdjustedNumCreatedFIDs = 0;
5918 for (
unsigned I = FID.ID, N = I + NumCreatedFIDs; I != N; ++I)
5919 if (IsSLocAffecting[I])
5920 ++AdjustedNumCreatedFIDs;
5921 return AdjustedNumCreatedFIDs;
5937 return Offset - getAdjustment(Offset);
5942 if (NonAffectingRanges.empty())
5948 if (Offset > NonAffectingRanges.back().getEnd().getOffset())
5949 return NonAffectingOffsetAdjustments.back();
5951 if (Offset < NonAffectingRanges.front().getBegin().getOffset())
5958 auto It = llvm::lower_bound(NonAffectingRanges, Offset, Contains);
5959 unsigned Idx = std::distance(NonAffectingRanges.begin(), It);
5960 return NonAffectingOffsetAdjustments[Idx];
5964 Record.push_back(getAdjustedFileID(FID).getOpaqueValue());
5969 unsigned BaseOffset = 0;
5970 unsigned ModuleFileIndex = 0;
5977 SourceManager::MaxLoadedOffset -
Loc.getOffset() - 1);
5978 assert(SLocMapI !=
getChain()->GlobalSLocOffsetMap.end() &&
5979 "Corrupted global sloc offset map");
5984 ModuleFileIndex = F->
Index + 1;
5993 Loc = getAdjustedLocation(
Loc);
6031 MacroInfoToEmitData Info = { Name, MI, ID };
6032 MacroInfosToEmit.push_back(Info);
6041 assert(MacroIDs.contains(MI) &&
"Macro not emitted!");
6042 return MacroIDs[MI];
6046 return IdentMacroDirectivesOffsetMap.lookup(Name);
6050 Record->push_back(Writer->getSelectorRef(SelRef));
6059 if (SID == 0 && Chain) {
6063 SID = SelectorIDs[Sel];
6066 SID = NextSelectorID++;
6067 SelectorIDs[Sel] = SID;
6109 bool InfoHasSameExpr
6111 Record->push_back(InfoHasSameExpr);
6112 if (InfoHasSameExpr)
6130 TypeLocWriter TLW(*
this,
Seq);
6139template <
typename IdxForTypeTy>
6141 IdxForTypeTy IdxForType) {
6145 unsigned FastQuals =
T.getLocalFastQualifiers();
6146 T.removeLocalFastQualifiers();
6148 if (
T.hasLocalNonFastQualifiers())
6149 return IdxForType(
T).asTypeID(FastQuals);
6151 assert(!
T.hasLocalQualifiers());
6153 if (
const BuiltinType *BT = dyn_cast<BuiltinType>(
T.getTypePtr()))
6161 return IdxForType(
T).asTypeID(FastQuals);
6169 assert(!
T.getLocalFastQualifiers());
6173 if (DoneWritingDeclsAndTypes) {
6174 assert(0 &&
"New type seen after serializing all the types to emit!");
6180 Idx =
TypeIdx(0, NextTypeID++);
6181 DeclTypesToEmit.push(
T);
6199 assert(WritingAST &&
"Cannot request a declaration ID before AST writing");
6206 if (
auto *
Iter = DeclUpdatesFromGMF.find(
D);
6207 Iter != DeclUpdatesFromGMF.end()) {
6209 DeclUpdates[
D].push_back(
Update);
6210 DeclUpdatesFromGMF.erase(
Iter);
6222 assert(!(
reinterpret_cast<uintptr_t>(
D) & 0x01) &&
"Invalid decl pointer");
6224 if (ID.isInvalid()) {
6225 if (DoneWritingDeclsAndTypes) {
6226 assert(0 &&
"New decl seen after serializing all the decls to emit!");
6233 DeclTypesToEmit.push(
const_cast<Decl *
>(
D));
6248 assert(DeclIDs.contains(
D) &&
"Declaration not emitted!");
6255 assert(DoneWritingDeclsAndTypes &&
6256 "wasDeclEmitted should only be called after writing declarations");
6261 bool Emitted = DeclIDs.contains(
D);
6263 GeneratingReducedBMI) &&
6264 "The declaration within modules can only be omitted in reduced BMI.");
6269 assert(ID.isValid());
6283 if (isa<ParmVarDecl, TemplateTemplateParmDecl>(
D))
6288 assert(
SM.isLocalSourceLocation(FileLoc));
6291 std::tie(FID, Offset) =
SM.getDecomposedLoc(FileLoc);
6294 assert(
SM.getSLocEntry(FID).isFile());
6295 assert(IsSLocAffecting[FID.ID]);
6297 std::unique_ptr<DeclIDInFileInfo> &Info = FileDeclIDs[FID];
6299 Info = std::make_unique<DeclIDInFileInfo>();
6301 std::pair<unsigned, LocalDeclID> LocDecl(Offset, ID);
6302 LocDeclIDsTy &Decls = Info->DeclIDs;
6303 Decls.push_back(LocDecl);
6308 "expected an anonymous declaration");
6312 auto It = AnonymousDeclarationNumbers.find(
D);
6313 if (It == AnonymousDeclarationNumbers.end()) {
6316 AnonymousDeclarationNumbers[ND] = Number;
6319 It = AnonymousDeclarationNumbers.find(
D);
6320 assert(It != AnonymousDeclarationNumbers.end() &&
6321 "declaration not found within its lexical context");
6329 switch (Name.getNameKind()) {
6376 NestedNames.push_back(NNS);
6380 Record->push_back(NestedNames.size());
6381 while(!NestedNames.empty()) {
6382 NNS = NestedNames.pop_back_val();
6424 assert(TemplateParams &&
"No TemplateParams!");
6430 for (
const auto &
P : *TemplateParams)
6436 Record->push_back(
false);
6443 assert(TemplateArgs &&
"No TemplateArgs!");
6445 for (
int i = 0, e = TemplateArgs->
size(); i != e; ++i)
6451 assert(ASTTemplArgList &&
"No ASTTemplArgList!");
6463 I =
Set.begin(),
E =
Set.end(); I !=
E; ++I) {
6465 Record->push_back(I.getAccess());
6473 Record->push_back(
Base.getAccessSpecifierAsWritten());
6474 Record->push_back(
Base.getInheritConstructors());
6487 for (
auto &
Base : Bases)
6505 for (
auto *
Init : CtorInits) {
6506 if (
Init->isBaseInitializer()) {
6510 }
else if (
Init->isDelegatingInitializer()) {
6513 }
else if (
Init->isMemberInitializer()){
6526 if (
Init->isWritten())
6540 auto &
Data =
D->data();
6546#define FIELD(Name, Width, Merge) \
6547 if (!DefinitionBits.canWriteNextNBits(Width)) { \
6548 Record->push_back(DefinitionBits); \
6549 DefinitionBits.reset(0); \
6551 DefinitionBits.addBits(Data.Name, Width);
6553#include "clang/AST/CXXRecordDeclDefinitionBits.def"
6556 Record->push_back(DefinitionBits);
6560 Record->push_back(
D->getODRHash());
6562 bool ModulesDebugInfo =
6563 Writer->Context->getLangOpts().ModulesDebugInfo && !
D->isDependentType();
6564 Record->push_back(ModulesDebugInfo);
6565 if (ModulesDebugInfo)
6566 Writer->AddDeclRef(
D, Writer->ModularCodegenDecls);
6571 Record->push_back(
Data.ComputedVisibleConversions);
6572 if (
Data.ComputedVisibleConversions)
6576 if (!
Data.IsLambda) {
6578 if (
Data.NumBases > 0)
6583 if (
Data.NumVBases > 0)
6588 auto &Lambda =
D->getLambdaData();
6591 LambdaBits.
addBits(Lambda.DependencyKind, 2);
6592 LambdaBits.
addBit(Lambda.IsGenericLambda);
6593 LambdaBits.
addBits(Lambda.CaptureDefault, 2);
6594 LambdaBits.
addBits(Lambda.NumCaptures, 15);
6595 LambdaBits.
addBit(Lambda.HasKnownInternalLinkage);
6596 Record->push_back(LambdaBits);
6598 Record->push_back(Lambda.NumExplicitCaptures);
6599 Record->push_back(Lambda.ManglingNumber);
6600 Record->push_back(
D->getDeviceLambdaManglingNumber());
6604 for (
unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
6611 Record->push_back(CaptureBits);
6613 switch (
Capture.getCaptureKind()) {
6640 Val |= (ES->HasConstantInitialization ? 2 : 0);
6641 Val |= (ES->HasConstantDestruction ? 4 : 0);
6655void ASTWriter::ReaderInitialized(
ASTReader *Reader) {
6656 assert(Reader &&
"Cannot remove chain");
6657 assert((!Chain || Chain == Reader) &&
"Cannot replace chain");
6658 assert(FirstDeclID == NextDeclID &&
6659 FirstTypeID == NextTypeID &&
6660 FirstIdentID == NextIdentID &&
6661 FirstMacroID == NextMacroID &&
6662 FirstSubmoduleID == NextSubmoduleID &&
6663 FirstSelectorID == NextSelectorID &&
6664 "Setting chain after writing has started.");
6673 NextMacroID = FirstMacroID;
6674 NextSelectorID = FirstSelectorID;
6675 NextSubmoduleID = FirstSubmoduleID;
6685 unsigned OriginalModuleFileIndex = StoredID >> 32;
6689 if (OriginalModuleFileIndex == 0 && StoredID)
6700 MacroID &StoredID = MacroIDs[MI];
6723 if (ModuleFileIndex == 0 && StoredIdx.
getValue())
6741 assert(!MacroDefinitions.contains(MD));
6742 MacroDefinitions[MD] =
ID;
6746 assert(!SubmoduleIDs.contains(Mod));
6747 SubmoduleIDs[Mod] =
ID;
6750void ASTWriter::CompletedTagDefinition(
const TagDecl *
D) {
6752 assert(
D->isCompleteDefinition());
6753 assert(!WritingAST &&
"Already writing the AST!");
6754 if (
auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
6756 if (RD->isFromASTFile()) {
6761 "completed a tag from another module but not by instantiation?");
6762 DeclUpdates[RD].push_back(
6780 "Should not add lookup results to non-lookup contexts!");
6783 if (isa<TranslationUnitDecl>(DC))
6791 !isa<FunctionTemplateDecl>(
D))
6801 assert(!WritingAST &&
"Already writing the AST!");
6802 if (UpdatedDeclContexts.insert(DC) && !cast<Decl>(DC)->isFromASTFile()) {
6806 llvm::append_range(DeclsToEmitEvenIfUnreferenced, DC->
decls());
6808 DeclsToEmitEvenIfUnreferenced.push_back(
D);
6820 if (!isa<CXXMethodDecl>(
D))
6825 assert(!WritingAST &&
"Already writing the AST!");
6829void ASTWriter::ResolvedExceptionSpec(
const FunctionDecl *FD) {
6831 assert(!DoneWritingDeclsAndTypes &&
"Already done writing updates!");
6838 ->castAs<FunctionProtoType>()
6839 ->getExceptionSpecType()))
6846 assert(!WritingAST &&
"Already writing the AST!");
6849 DeclUpdates[
D].push_back(
6858 assert(!WritingAST &&
"Already writing the AST!");
6859 assert(
Delete &&
"Not given an operator delete");
6866void ASTWriter::CompletedImplicitDefinition(
const FunctionDecl *
D) {
6868 assert(!WritingAST &&
"Already writing the AST!");
6876void ASTWriter::VariableDefinitionInstantiated(
const VarDecl *
D) {
6878 assert(!WritingAST &&
"Already writing the AST!");
6885void ASTWriter::FunctionDefinitionInstantiated(
const FunctionDecl *
D) {
6887 assert(!WritingAST &&
"Already writing the AST!");
6894void ASTWriter::InstantiationRequested(
const ValueDecl *
D) {
6896 assert(!WritingAST &&
"Already writing the AST!");
6903 if (
auto *VD = dyn_cast<VarDecl>(
D))
6904 POI = VD->getPointOfInstantiation();
6906 POI = cast<FunctionDecl>(
D)->getPointOfInstantiation();
6910void ASTWriter::DefaultArgumentInstantiated(
const ParmVarDecl *
D) {
6912 assert(!WritingAST &&
"Already writing the AST!");
6916 DeclUpdates[
D].push_back(
6920void ASTWriter::DefaultMemberInitializerInstantiated(
const FieldDecl *
D) {
6921 assert(!WritingAST &&
"Already writing the AST!");
6925 DeclUpdates[
D].push_back(
6932 assert(!WritingAST &&
"Already writing the AST!");
6936 assert(IFD->
getDefinition() &&
"Category on a class without a definition?");
6937 ObjCClassesWithCategories.insert(
6941void ASTWriter::DeclarationMarkedUsed(
const Decl *
D) {
6943 assert(!WritingAST &&
"Already writing the AST!");
6955void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(
const Decl *
D) {
6957 assert(!WritingAST &&
"Already writing the AST!");
6964void ASTWriter::DeclarationMarkedOpenMPAllocate(
const Decl *
D,
const Attr *A) {
6966 assert(!WritingAST &&
"Already writing the AST!");
6973void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(
const Decl *
D,
6976 assert(!WritingAST &&
"Already writing the AST!");
6980 DeclUpdates[
D].push_back(
6986 assert(!WritingAST &&
"Already writing the AST!");
6991void ASTWriter::AddedAttributeToRecord(
const Attr *
Attr,
6994 assert(!WritingAST &&
"Already writing the AST!");
6995 if (!
Record->isFromASTFile())
7000void ASTWriter::AddedCXXTemplateSpecialization(
7002 assert(!WritingAST &&
"Already writing the AST!");
7009 DeclsToEmitEvenIfUnreferenced.push_back(
D);
7012void ASTWriter::AddedCXXTemplateSpecialization(
7014 assert(!WritingAST &&
"Already writing the AST!");
7021 DeclsToEmitEvenIfUnreferenced.push_back(
D);
7026 assert(!WritingAST &&
"Already writing the AST!");
7033 DeclsToEmitEvenIfUnreferenced.push_back(
D);
7047#define GEN_CLANG_CLAUSE_CLASS
7048#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
7049#include "llvm/Frontend/OpenMP/OMP.inc"
7058 OMPClauseWriter(*this).writeClause(
C);
7061void OMPClauseWriter::writeClause(
OMPClause *
C) {
7062 Record.push_back(
unsigned(
C->getClauseKind()));
7064 Record.AddSourceLocation(
C->getBeginLoc());
7065 Record.AddSourceLocation(
C->getEndLoc());
7069 Record.push_back(uint64_t(
C->getCaptureRegion()));
7070 Record.AddStmt(
C->getPreInitStmt());
7074 VisitOMPClauseWithPreInit(
C);
7075 Record.AddStmt(
C->getPostUpdateExpr());
7078void OMPClauseWriter::VisitOMPIfClause(
OMPIfClause *
C) {
7079 VisitOMPClauseWithPreInit(
C);
7081 Record.AddSourceLocation(
C->getNameModifierLoc());
7082 Record.AddSourceLocation(
C->getColonLoc());
7083 Record.AddStmt(
C->getCondition());
7084 Record.AddSourceLocation(
C->getLParenLoc());
7088 VisitOMPClauseWithPreInit(
C);
7089 Record.AddStmt(
C->getCondition());
7090 Record.AddSourceLocation(
C->getLParenLoc());
7094 VisitOMPClauseWithPreInit(
C);
7095 Record.AddStmt(
C->getNumThreads());
7096 Record.AddSourceLocation(
C->getLParenLoc());
7100 Record.AddStmt(
C->getSafelen());
7101 Record.AddSourceLocation(
C->getLParenLoc());
7105 Record.AddStmt(
C->getSimdlen());
7106 Record.AddSourceLocation(
C->getLParenLoc());
7110 Record.push_back(
C->getNumSizes());
7111 for (
Expr *Size :
C->getSizesRefs())
7113 Record.AddSourceLocation(
C->getLParenLoc());
7119 Record.AddStmt(
C->getFactor());
7120 Record.AddSourceLocation(
C->getLParenLoc());
7124 Record.AddStmt(
C->getAllocator());
7125 Record.AddSourceLocation(
C->getLParenLoc());
7129 Record.AddStmt(
C->getNumForLoops());
7130 Record.AddSourceLocation(
C->getLParenLoc());
7134 Record.AddStmt(
C->getEventHandler());
7135 Record.AddSourceLocation(
C->getLParenLoc());
7139 Record.push_back(
unsigned(
C->getDefaultKind()));
7140 Record.AddSourceLocation(
C->getLParenLoc());
7141 Record.AddSourceLocation(
C->getDefaultKindKwLoc());
7145 Record.push_back(
unsigned(
C->getProcBindKind()));
7146 Record.AddSourceLocation(
C->getLParenLoc());
7147 Record.AddSourceLocation(
C->getProcBindKindKwLoc());
7151 VisitOMPClauseWithPreInit(
C);
7152 Record.push_back(
C->getScheduleKind());
7153 Record.push_back(
C->getFirstScheduleModifier());
7154 Record.push_back(
C->getSecondScheduleModifier());
7155 Record.AddStmt(
C->getChunkSize());
7156 Record.AddSourceLocation(
C->getLParenLoc());
7157 Record.AddSourceLocation(
C->getFirstScheduleModifierLoc());
7158 Record.AddSourceLocation(
C->getSecondScheduleModifierLoc());
7159 Record.AddSourceLocation(
C->getScheduleKindLoc());
7160 Record.AddSourceLocation(
C->getCommaLoc());
7164 Record.push_back(
C->getLoopNumIterations().size());
7165 Record.AddStmt(
C->getNumForLoops());
7166 for (
Expr *NumIter :
C->getLoopNumIterations())
7168 for (
unsigned I = 0,
E =
C->getLoopNumIterations().size(); I <
E; ++I)
7169 Record.AddStmt(
C->getLoopCounter(I));
7170 Record.AddSourceLocation(
C->getLParenLoc());
7184 Record.push_back(
C->isExtended() ? 1 : 0);
7185 if (
C->isExtended()) {
7186 Record.AddSourceLocation(
C->getLParenLoc());
7187 Record.AddSourceLocation(
C->getArgumentLoc());
7188 Record.writeEnum(
C->getDependencyKind());
7198 Record.AddSourceLocation(
C->getLParenLoc());
7199 Record.AddSourceLocation(
C->getFailParameterLoc());
7200 Record.writeEnum(
C->getFailParameter());
7222 Record.push_back(
C->varlist_size());
7223 for (
Expr *VE :
C->varlists())
7225 Record.writeBool(
C->getIsTarget());
7226 Record.writeBool(
C->getIsTargetSync());
7227 Record.AddSourceLocation(
C->getLParenLoc());
7228 Record.AddSourceLocation(
C->getVarLoc());
7232 Record.AddStmt(
C->getInteropVar());
7233 Record.AddSourceLocation(
C->getLParenLoc());
7234 Record.AddSourceLocation(
C->getVarLoc());
7238 Record.AddStmt(
C->getInteropVar());
7239 Record.AddSourceLocation(
C->getLParenLoc());
7240 Record.AddSourceLocation(
C->getVarLoc());
7244 VisitOMPClauseWithPreInit(
C);
7245 Record.AddStmt(
C->getCondition());
7246 Record.AddSourceLocation(
C->getLParenLoc());
7250 VisitOMPClauseWithPreInit(
C);
7251 Record.AddStmt(
C->getCondition());
7252 Record.AddSourceLocation(
C->getLParenLoc());
7256 VisitOMPClauseWithPreInit(
C);
7257 Record.AddStmt(
C->getThreadID());
7258 Record.AddSourceLocation(
C->getLParenLoc());
7262 Record.AddStmt(
C->getAlignment());
7263 Record.AddSourceLocation(
C->getLParenLoc());
7267 Record.push_back(
C->varlist_size());
7268 Record.AddSourceLocation(
C->getLParenLoc());
7269 for (
auto *VE :
C->varlists()) {
7272 for (
auto *VE :
C->private_copies()) {
7278 Record.push_back(
C->varlist_size());
7279 VisitOMPClauseWithPreInit(
C);
7280 Record.AddSourceLocation(
C->getLParenLoc());
7281 for (
auto *VE :
C->varlists()) {
7284 for (
auto *VE :
C->private_copies()) {
7287 for (
auto *VE :
C->inits()) {
7293 Record.push_back(
C->varlist_size());
7294 VisitOMPClauseWithPostUpdate(
C);
7295 Record.AddSourceLocation(
C->getLParenLoc());
7296 Record.writeEnum(
C->getKind());
7297 Record.AddSourceLocation(
C->getKindLoc());
7298 Record.AddSourceLocation(
C->getColonLoc());
7299 for (
auto *VE :
C->varlists())
7301 for (
auto *
E :
C->private_copies())
7303 for (
auto *
E :
C->source_exprs())
7305 for (
auto *
E :
C->destination_exprs())
7307 for (
auto *
E :
C->assignment_ops())
7312 Record.push_back(
C->varlist_size());
7313 Record.AddSourceLocation(
C->getLParenLoc());
7314 for (
auto *VE :
C->varlists())
7319 Record.push_back(
C->varlist_size());
7320 Record.writeEnum(
C->getModifier());
7321 VisitOMPClauseWithPostUpdate(
C);
7322 Record.AddSourceLocation(
C->getLParenLoc());
7323 Record.AddSourceLocation(
C->getModifierLoc());
7324 Record.AddSourceLocation(
C->getColonLoc());
7325 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7326 Record.AddDeclarationNameInfo(
C->getNameInfo());
7327 for (
auto *VE :
C->varlists())
7329 for (
auto *VE :
C->privates())
7331 for (
auto *
E :
C->lhs_exprs())
7333 for (
auto *
E :
C->rhs_exprs())
7335 for (
auto *
E :
C->reduction_ops())
7337 if (
C->getModifier() == clang::OMPC_REDUCTION_inscan) {
7338 for (
auto *
E :
C->copy_ops())
7340 for (
auto *
E :
C->copy_array_temps())
7342 for (
auto *
E :
C->copy_array_elems())
7348 Record.push_back(
C->varlist_size());
7349 VisitOMPClauseWithPostUpdate(
C);
7350 Record.AddSourceLocation(
C->getLParenLoc());
7351 Record.AddSourceLocation(
C->getColonLoc());
7352 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7353 Record.AddDeclarationNameInfo(
C->getNameInfo());
7354 for (
auto *VE :
C->varlists())
7356 for (
auto *VE :
C->privates())
7358 for (
auto *
E :
C->lhs_exprs())
7360 for (
auto *
E :
C->rhs_exprs())
7362 for (
auto *
E :
C->reduction_ops())
7367 Record.push_back(
C->varlist_size());
7368 VisitOMPClauseWithPostUpdate(
C);
7369 Record.AddSourceLocation(
C->getLParenLoc());
7370 Record.AddSourceLocation(
C->getColonLoc());
7371 Record.AddNestedNameSpecifierLoc(
C->getQualifierLoc());
7372 Record.AddDeclarationNameInfo(
C->getNameInfo());
7373 for (
auto *VE :
C->varlists())
7375 for (
auto *VE :
C->privates())
7377 for (
auto *
E :
C->lhs_exprs())
7379 for (
auto *
E :
C->rhs_exprs())
7381 for (
auto *
E :
C->reduction_ops())
7383 for (
auto *
E :
C->taskgroup_descriptors())
7388 Record.push_back(
C->varlist_size());
7389 VisitOMPClauseWithPostUpdate(
C);
7390 Record.AddSourceLocation(
C->getLParenLoc());
7391 Record.AddSourceLocation(
C->getColonLoc());
7392 Record.push_back(
C->getModifier());
7393 Record.AddSourceLocation(
C->getModifierLoc());
7394 for (
auto *VE :
C->varlists()) {
7397 for (
auto *VE :
C->privates()) {
7400 for (
auto *VE :
C->inits()) {
7403 for (
auto *VE :
C->updates()) {
7406 for (
auto *VE :
C->finals()) {
7410 Record.AddStmt(
C->getCalcStep());
7411 for (
auto *VE :
C->used_expressions())
7416 Record.push_back(
C->varlist_size());
7417 Record.AddSourceLocation(
C->getLParenLoc());
7418 Record.AddSourceLocation(
C->getColonLoc());
7419 for (
auto *VE :
C->varlists())
7421 Record.AddStmt(
C->getAlignment());
7425 Record.push_back(
C->varlist_size());
7426 Record.AddSourceLocation(
C->getLParenLoc());
7427 for (
auto *VE :
C->varlists())
7429 for (
auto *
E :
C->source_exprs())
7431 for (
auto *
E :
C->destination_exprs())
7433 for (
auto *
E :
C->assignment_ops())
7438 Record.push_back(
C->varlist_size());
7439 Record.AddSourceLocation(
C->getLParenLoc());
7440 for (
auto *VE :
C->varlists())
7442 for (
auto *
E :
C->source_exprs())
7444 for (
auto *
E :
C->destination_exprs())
7446 for (
auto *
E :
C->assignment_ops())
7451 Record.push_back(
C->varlist_size());
7452 Record.AddSourceLocation(
C->getLParenLoc());
7453 for (
auto *VE :
C->varlists())
7458 Record.AddStmt(
C->getDepobj());
7459 Record.AddSourceLocation(
C->getLParenLoc());
7463 Record.push_back(
C->varlist_size());
7464 Record.push_back(
C->getNumLoops());
7465 Record.AddSourceLocation(
C->getLParenLoc());
7466 Record.AddStmt(
C->getModifier());
7467 Record.push_back(
C->getDependencyKind());
7468 Record.AddSourceLocation(
C->getDependencyLoc());
7469 Record.AddSourceLocation(
C->getColonLoc());
7470 Record.AddSourceLocation(
C->getOmpAllMemoryLoc());
7471 for (
auto *VE :
C->varlists())
7473 for (
unsigned I = 0,
E =
C->getNumLoops(); I <
E; ++I)
7474 Record.AddStmt(
C->getLoopData(I));
7478 VisitOMPClauseWithPreInit(
C);
7479 Record.writeEnum(
C->getModifier());
7480 Record.AddStmt(
C->getDevice());
7481 Record.AddSourceLocation(
C->getModifierLoc());
7482 Record.AddSourceLocation(
C->getLParenLoc());
7486 Record.push_back(
C->varlist_size());
7487 Record.push_back(
C->getUniqueDeclarationsNum());
7488 Record.push_back(
C->getTotalComponentListNum());
7489 Record.push_back(
C->getTotalComponentsNum());
7490 Record.AddSourceLocation(
C->getLParenLoc());
7491 bool HasIteratorModifier =
false;
7493 Record.push_back(
C->getMapTypeModifier(I));
7494 Record.AddSourceLocation(
C->getMapTypeModifierLoc(I));
7495 if (
C->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator)
7496 HasIteratorModifier =
true;
7498 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7499 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7500 Record.push_back(
C->getMapType());
7501 Record.AddSourceLocation(
C->getMapLoc());
7502 Record.AddSourceLocation(
C->getColonLoc());
7503 for (
auto *
E :
C->varlists())
7505 for (
auto *
E :
C->mapperlists())
7507 if (HasIteratorModifier)
7508 Record.AddStmt(
C->getIteratorModifier());
7509 for (
auto *
D :
C->all_decls())
7511 for (
auto N :
C->all_num_lists())
7513 for (
auto N :
C->all_lists_sizes())
7515 for (
auto &M :
C->all_components()) {
7516 Record.AddStmt(M.getAssociatedExpression());
7517 Record.AddDeclRef(M.getAssociatedDeclaration());
7522 Record.push_back(
C->varlist_size());
7523 Record.AddSourceLocation(
C->getLParenLoc());
7524 Record.AddSourceLocation(
C->getColonLoc());
7525 Record.AddStmt(
C->getAllocator());
7526 for (
auto *VE :
C->varlists())
7531 VisitOMPClauseWithPreInit(
C);
7532 Record.AddStmt(
C->getNumTeams());
7533 Record.AddSourceLocation(
C->getLParenLoc());
7537 VisitOMPClauseWithPreInit(
C);
7538 Record.AddStmt(
C->getThreadLimit());
7539 Record.AddSourceLocation(
C->getLParenLoc());
7543 VisitOMPClauseWithPreInit(
C);
7544 Record.AddStmt(
C->getPriority());
7545 Record.AddSourceLocation(
C->getLParenLoc());
7549 VisitOMPClauseWithPreInit(
C);
7550 Record.writeEnum(
C->getModifier());
7551 Record.AddStmt(
C->getGrainsize());
7552 Record.AddSourceLocation(
C->getModifierLoc());
7553 Record.AddSourceLocation(
C->getLParenLoc());
7557 VisitOMPClauseWithPreInit(
C);
7558 Record.writeEnum(
C->getModifier());
7559 Record.AddStmt(
C->getNumTasks());
7560 Record.AddSourceLocation(
C->getModifierLoc());
7561 Record.AddSourceLocation(
C->getLParenLoc());
7566 Record.AddSourceLocation(
C->getLParenLoc());
7570 VisitOMPClauseWithPreInit(
C);
7571 Record.push_back(
C->getDistScheduleKind());
7572 Record.AddStmt(
C->getChunkSize());
7573 Record.AddSourceLocation(
C->getLParenLoc());
7574 Record.AddSourceLocation(
C->getDistScheduleKindLoc());
7575 Record.AddSourceLocation(
C->getCommaLoc());
7579 Record.push_back(
C->getDefaultmapKind());
7580 Record.push_back(
C->getDefaultmapModifier());
7581 Record.AddSourceLocation(
C->getLParenLoc());
7582 Record.AddSourceLocation(
C->getDefaultmapModifierLoc());
7583 Record.AddSourceLocation(
C->getDefaultmapKindLoc());
7586void OMPClauseWriter::VisitOMPToClause(
OMPToClause *
C) {
7587 Record.push_back(
C->varlist_size());
7588 Record.push_back(
C->getUniqueDeclarationsNum());
7589 Record.push_back(
C->getTotalComponentListNum());
7590 Record.push_back(
C->getTotalComponentsNum());
7591 Record.AddSourceLocation(
C->getLParenLoc());
7593 Record.push_back(
C->getMotionModifier(I));
7594 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
7596 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7597 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7598 Record.AddSourceLocation(
C->getColonLoc());
7599 for (
auto *
E :
C->varlists())
7601 for (
auto *
E :
C->mapperlists())
7603 for (
auto *
D :
C->all_decls())
7605 for (
auto N :
C->all_num_lists())
7607 for (
auto N :
C->all_lists_sizes())
7609 for (
auto &M :
C->all_components()) {
7610 Record.AddStmt(M.getAssociatedExpression());
7611 Record.writeBool(M.isNonContiguous());
7612 Record.AddDeclRef(M.getAssociatedDeclaration());
7617 Record.push_back(
C->varlist_size());
7618 Record.push_back(
C->getUniqueDeclarationsNum());
7619 Record.push_back(
C->getTotalComponentListNum());
7620 Record.push_back(
C->getTotalComponentsNum());
7621 Record.AddSourceLocation(
C->getLParenLoc());
7623 Record.push_back(
C->getMotionModifier(I));
7624 Record.AddSourceLocation(
C->getMotionModifierLoc(I));
7626 Record.AddNestedNameSpecifierLoc(
C->getMapperQualifierLoc());
7627 Record.AddDeclarationNameInfo(
C->getMapperIdInfo());
7628 Record.AddSourceLocation(
C->getColonLoc());
7629 for (
auto *
E :
C->varlists())
7631 for (
auto *
E :
C->mapperlists())
7633 for (
auto *
D :
C->all_decls())
7635 for (
auto N :
C->all_num_lists())
7637 for (
auto N :
C->all_lists_sizes())
7639 for (
auto &M :
C->all_components()) {
7640 Record.AddStmt(M.getAssociatedExpression());
7641 Record.writeBool(M.isNonContiguous());
7642 Record.AddDeclRef(M.getAssociatedDeclaration());
7647 Record.push_back(
C->varlist_size());
7648 Record.push_back(
C->getUniqueDeclarationsNum());
7649 Record.push_back(
C->getTotalComponentListNum());
7650 Record.push_back(
C->getTotalComponentsNum());
7651 Record.AddSourceLocation(
C->getLParenLoc());
7652 for (
auto *
E :
C->varlists())
7654 for (
auto *VE :
C->private_copies())
7656 for (
auto *VE :
C->inits())
7658 for (
auto *
D :
C->all_decls())
7660 for (
auto N :
C->all_num_lists())
7662 for (
auto N :
C->all_lists_sizes())
7664 for (
auto &M :
C->all_components()) {
7665 Record.AddStmt(M.getAssociatedExpression());
7666 Record.AddDeclRef(M.getAssociatedDeclaration());
7671 Record.push_back(
C->varlist_size());
7672 Record.push_back(
C->getUniqueDeclarationsNum());
7673 Record.push_back(
C->getTotalComponentListNum());
7674 Record.push_back(
C->getTotalComponentsNum());
7675 Record.AddSourceLocation(
C->getLParenLoc());
7676 for (
auto *
E :
C->varlists())
7678 for (
auto *
D :
C->all_decls())
7680 for (
auto N :
C->all_num_lists())
7682 for (
auto N :
C->all_lists_sizes())
7684 for (
auto &M :
C->all_components()) {
7685 Record.AddStmt(M.getAssociatedExpression());
7686 Record.AddDeclRef(M.getAssociatedDeclaration());
7691 Record.push_back(
C->varlist_size());
7692 Record.push_back(
C->getUniqueDeclarationsNum());
7693 Record.push_back(
C->getTotalComponentListNum());
7694 Record.push_back(
C->getTotalComponentsNum());
7695 Record.AddSourceLocation(
C->getLParenLoc());
7696 for (
auto *
E :
C->varlists())
7698 for (
auto *
D :
C->all_decls())
7700 for (
auto N :
C->all_num_lists())
7702 for (
auto N :
C->all_lists_sizes())
7704 for (
auto &M :
C->all_components()) {
7705 Record.AddStmt(M.getAssociatedExpression());
7706 Record.AddDeclRef(M.getAssociatedDeclaration());
7711 Record.push_back(
C->varlist_size());
7712 Record.push_back(
C->getUniqueDeclarationsNum());
7713 Record.push_back(
C->getTotalComponentListNum());
7714 Record.push_back(
C->getTotalComponentsNum());
7715 Record.AddSourceLocation(
C->getLParenLoc());
7716 for (
auto *
E :
C->varlists())
7718 for (
auto *
D :
C->all_decls())
7720 for (
auto N :
C->all_num_lists())
7722 for (
auto N :
C->all_lists_sizes())
7724 for (
auto &M :
C->all_components()) {
7725 Record.AddStmt(M.getAssociatedExpression());
7726 Record.AddDeclRef(M.getAssociatedDeclaration());
7732void OMPClauseWriter::VisitOMPUnifiedSharedMemoryClause(
7741void OMPClauseWriter::VisitOMPAtomicDefaultMemOrderClause(
7743 Record.push_back(
C->getAtomicDefaultMemOrderKind());
7744 Record.AddSourceLocation(
C->getLParenLoc());
7745 Record.AddSourceLocation(
C->getAtomicDefaultMemOrderKindKwLoc());
7748void OMPClauseWriter::VisitOMPAtClause(
OMPAtClause *
C) {
7749 Record.push_back(
C->getAtKind());
7750 Record.AddSourceLocation(
C->getLParenLoc());
7751 Record.AddSourceLocation(
C->getAtKindKwLoc());
7755 Record.push_back(
C->getSeverityKind());
7756 Record.AddSourceLocation(
C->getLParenLoc());
7757 Record.AddSourceLocation(
C->getSeverityKindKwLoc());
7761 Record.AddStmt(
C->getMessageString());
7762 Record.AddSourceLocation(
C->getLParenLoc());
7766 Record.push_back(
C->varlist_size());
7767 Record.AddSourceLocation(
C->getLParenLoc());
7768 for (
auto *VE :
C->varlists())
7770 for (
auto *
E :
C->private_refs())
7775 Record.push_back(
C->varlist_size());
7776 Record.AddSourceLocation(
C->getLParenLoc());
7777 for (
auto *VE :
C->varlists())
7782 Record.push_back(
C->varlist_size());
7783 Record.AddSourceLocation(
C->getLParenLoc());
7784 for (
auto *VE :
C->varlists())
7789 Record.writeEnum(
C->getKind());
7790 Record.writeEnum(
C->getModifier());
7791 Record.AddSourceLocation(
C->getLParenLoc());
7792 Record.AddSourceLocation(
C->getKindKwLoc());
7793 Record.AddSourceLocation(
C->getModifierKwLoc());
7797 Record.push_back(
C->getNumberOfAllocators());
7798 Record.AddSourceLocation(
C->getLParenLoc());
7799 for (
unsigned I = 0,
E =
C->getNumberOfAllocators(); I <
E; ++I) {
7809 Record.push_back(
C->varlist_size());
7810 Record.AddSourceLocation(
C->getLParenLoc());
7811 Record.AddStmt(
C->getModifier());
7812 Record.AddSourceLocation(
C->getColonLoc());
7813 for (
Expr *
E :
C->varlists())
7818 Record.writeEnum(
C->getBindKind());
7819 Record.AddSourceLocation(
C->getLParenLoc());
7820 Record.AddSourceLocation(
C->getBindKindLoc());
7824 VisitOMPClauseWithPreInit(
C);
7826 Record.AddSourceLocation(
C->getLParenLoc());
7830 Record.push_back(
C->varlist_size());
7831 Record.push_back(
C->getNumLoops());
7832 Record.AddSourceLocation(
C->getLParenLoc());
7833 Record.push_back(
C->getDependenceType());
7834 Record.AddSourceLocation(
C->getDependenceLoc());
7835 Record.AddSourceLocation(
C->getColonLoc());
7836 for (
auto *VE :
C->varlists())
7838 for (
unsigned I = 0,
E =
C->getNumLoops(); I <
E; ++I)
7839 Record.AddStmt(
C->getLoopData(I));
7843 Record.AddAttributes(
C->getAttrs());
7844 Record.AddSourceLocation(
C->getBeginLoc());
7845 Record.AddSourceLocation(
C->getLParenLoc());
7846 Record.AddSourceLocation(
C->getEndLoc());
7853 for (
const auto &
Set : TI->
Sets) {
7860 writeExprRef(
Selector.ScoreOrCondition);
7874 for (
unsigned I = 0,
E =
Data->getNumClauses(); I <
E; ++I)
7876 if (
Data->hasAssociatedStmt())
7878 for (
unsigned I = 0,
E =
Data->getNumChildren(); I <
E; ++I)
7884 for (
Expr *
E :
C->getVarList())
7890 for (
Expr *
E : Exprs)
7899 switch (
C->getClauseKind()) {
7901 const auto *DC = cast<OpenACCDefaultClause>(
C);
7907 const auto *IC = cast<OpenACCIfClause>(
C);
7909 AddStmt(
const_cast<Expr*
>(IC->getConditionExpr()));
7913 const auto *SC = cast<OpenACCSelfClause>(
C);
7916 if (SC->hasConditionExpr())
7917 AddStmt(
const_cast<Expr*
>(SC->getConditionExpr()));
7921 const auto *NGC = cast<OpenACCNumGangsClause>(
C);
7924 for (
Expr *
E : NGC->getIntExprs())
7929 const auto *NWC = cast<OpenACCNumWorkersClause>(
C);
7935 const auto *NWC = cast<OpenACCVectorLengthClause>(
C);
7941 const auto *PC = cast<OpenACCPrivateClause>(
C);
7947 const auto *FPC = cast<OpenACCFirstPrivateClause>(
C);
7953 const auto *AC = cast<OpenACCAttachClause>(
C);
7959 const auto *DPC = cast<OpenACCDevicePtrClause>(
C);
7965 const auto *NCC = cast<OpenACCNoCreateClause>(
C);
7971 const auto *PC = cast<OpenACCPresentClause>(
C);
7979 const auto *CC = cast<OpenACCCopyClause>(
C);
7987 const auto *CIC = cast<OpenACCCopyInClause>(
C);
7996 const auto *COC = cast<OpenACCCopyOutClause>(
C);
8005 const auto *CC = cast<OpenACCCreateClause>(
C);
8012 const auto *AC = cast<OpenACCAsyncClause>(
C);
8015 if (AC->hasIntExpr())
8020 const auto *WC = cast<OpenACCWaitClause>(
C);
8023 if (
Expr *DNE = WC->getDevNumExpr())
8032 const auto *DTC = cast<OpenACCDeviceTypeClause>(
C);
8044 const auto *RC = cast<OpenACCReductionClause>(
C);
8076 llvm_unreachable(
"Clause serialization not yet implemented");
8078 llvm_unreachable(
"Invalid Clause Kind");
Defines the clang::ASTContext interface.
static bool isInterestingIdentifier(ASTReader &Reader, const IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
static NamedDecl * getDeclForLocalLookup(const LangOptions &LangOpts, NamedDecl *D)
Determine the declaration that should be put into the name lookup table to represent the given declar...
static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream)
Create an abbreviation for the SLocEntry that refers to a buffer.
static bool isLookupResultNotInteresting(ASTWriter &Writer, StoredDeclsList &Result)
Returns ture if all of the lookup result are either external, not emitted or predefined.
static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec)
static bool IsInternalDeclFromFileContext(const Decl *D)
static TypeID MakeTypeID(ASTContext &Context, QualType T, IdxForTypeTy IdxForType)
static void AddLazyVectorEmiitedDecls(ASTWriter &Writer, Vector &Vec, ASTWriter::RecordData &Record)
static 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 bool isLocalIdentifierID(IdentifierID ID)
If the.
static unsigned getNumberOfModules(Module *Mod)
Compute the number of modules within the given tree (including the given module).
static bool isImportedDeclContext(ASTReader *Chain, const Decl *D)
static TypeCode getTypeCodeForTypeClass(Type::TypeClass id)
static void AddStmtsExprs(llvm::BitstreamWriter &Stream, ASTWriter::RecordDataImpl &Record)
static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob, unsigned SLocBufferBlobCompressedAbbrv, unsigned SLocBufferBlobAbbrv)
static uint64_t EmitCXXBaseSpecifiers(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.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
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.
void forEachImportedKeyDecl(const Decl *D, Fn Visit)
Run a callback on each imported key declaration of D.
unsigned getTotalNumSelectors() const
Returns the number of selectors found in the chain.
unsigned getModuleFileID(ModuleFile *M)
Get an ID for the given module file.
Decl * getKeyDeclaration(Decl *D)
Returns the first key declaration for the given declaration.
void LoadSelector(Selector Sel)
Load a selector from disk, registering its ID if it exists.
bool isProcessingUpdateRecords()
unsigned getTotalNumMacros() const
Returns the number of macros found in the chain.
An object for streaming information to a record.
void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo)
void AddCXXBaseSpecifiers(ArrayRef< CXXBaseSpecifier > Bases)
Emit a set of C++ base specifiers.
void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs)
Emit a template argument list.
uint64_t Emit(unsigned Code, unsigned Abbrev=0)
Emit the record to the stream, followed by its substatements, and return its offset.
void AddCXXTemporary(const CXXTemporary *Temp)
Emit a CXXTemporary.
void writeOMPTraitInfo(const OMPTraitInfo *TI)
Write an OMPTraitInfo object.
void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base)
Emit a C++ base specifier.
void writeOMPClause(OMPClause *C)
void writeBool(bool Value)
void AddAPValue(const APValue &Value)
Emit an APvalue.
void AddUnresolvedSet(const ASTUnresolvedSet &Set)
Emit a UnresolvedSet structure.
void AddIdentifierRef(const IdentifierInfo *II)
Emit a reference to an identifier.
void AddStmt(Stmt *S)
Add the given statement or expression to the queue of statements to emit.
void AddDeclarationName(DeclarationName Name)
Emit a declaration name.
void AddSelectorRef(Selector S)
Emit a Selector (which is a smart pointer reference).
void AddSourceRange(SourceRange Range, LocSeq *Seq=nullptr)
Emit a source range.
void writeSourceLocation(SourceLocation Loc)
void AddOffset(uint64_t BitOffset)
Add a bit offset into the record.
void AddTypeRef(QualType T)
Emit a reference to a type.
void writeQualType(QualType T)
void writeOpenACCClauseList(ArrayRef< const OpenACCClause * > Clauses)
Writes out a list of OpenACC clauses.
void AddSourceLocation(SourceLocation Loc, LocSeq *Seq=nullptr)
Emit a source location.
void push_back(uint64_t N)
Minimal vector-like interface.
void AddTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Emits source location information for a type. Does not emit the type.
void AddCXXCtorInitializers(ArrayRef< CXXCtorInitializer * > CtorInits)
Emit a CXXCtorInitializer array.
void AddTemplateParameterList(const TemplateParameterList *TemplateParams)
Emit a template parameter list.
void AddTemplateArgument(const TemplateArgument &Arg)
Emit a template argument.
void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name)
void writeOpenACCIntExprList(ArrayRef< Expr * > Exprs)
void AddAPFloat(const llvm::APFloat &Value)
Emit a floating-point value.
void AddTypeSourceInfo(TypeSourceInfo *TInfo)
Emits a reference to a declarator info.
void AddQualifierInfo(const QualifierInfo &Info)
void writeUInt32(uint32_t Value)
void AddDeclRef(const Decl *D)
Emit a reference to a declaration.
void writeOMPChildren(OMPChildren *Data)
Writes data related to the OpenMP directives.
void AddConceptReference(const ConceptReference *CR)
void AddAPInt(const llvm::APInt &Value)
Emit an integral value.
void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg)
Emits a template argument location info.
void writeOpenACCVarList(const OpenACCClauseWithVarList *C)
void AddAttributes(ArrayRef< const Attr * > Attrs)
Emit a list of attributes.
void AddASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *ASTTemplArgList)
Emits an AST template argument list info.
void AddCXXDefinitionData(const CXXRecordDecl *D)
void AddVarDeclInit(const VarDecl *VD)
Emit information about the initializer of a VarDecl.
void writeStmtRef(const Stmt *S)
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg)
Emits a template argument location.
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)
Emit a nested name specifier with source-location information.
void writeOpenACCClause(const OpenACCClause *C)
Writes out a single OpenACC Clause.
void AddAttr(const Attr *A)
An UnresolvedSet-like class which uses the ASTContext's allocator.
Writes an AST file containing the contents of a translation unit.
serialization::MacroID getMacroID(MacroInfo *MI)
Determine the ID of an already-emitted macro.
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.
bool isDeclPredefined(const Decl *D) const
void AddPath(StringRef Path, RecordDataImpl &Record)
Add a path to the given record.
unsigned getTypeExtQualAbbrev() const
void AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record)
Add a version tuple to the given record.
bool isGeneratingReducedBMI() const
uint32_t getMacroDirectivesOffset(const IdentifierInfo *Name)
void AddAlignPackInfo(const Sema::AlignPackInfo &Info, RecordDataImpl &Record)
Emit a AlignPackInfo.
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.
bool isWritingModule() const
LocalDeclID GetDeclRef(const Decl *D)
Force a declaration to be emitted and get its local ID to the module file been writing.
LocalDeclID getDeclID(const Decl *D)
Determine the local declaration ID of an already-emitted declaration.
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
serialization::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.
Represents a C++ temporary.
const CXXDestructorDecl * getDestructor() const
Declaration of a class template.
Represents a class template specialization, which refers to a class template with a given set of temp...
A reference to a concept and its template args, as it appears in the code.
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
NamedDecl * getFoundDecl() const
const DeclarationNameInfo & getConceptNameInfo() const
ConceptDecl * getNamedConcept() const
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
SourceLocation getTemplateKWLoc() const
Wrapper for source info for pointers decayed from arrays and functions.
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isFileContext() const
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool isLookupContext() const
Test whether the context supports looking up names.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
StoredDeclsMap * buildLookup()
Ensure the lookup structure is fully-built and return it.
lookup_result noload_lookup(DeclarationName Name)
Find the declarations with the given name that are visible within this context; don't attempt to retr...
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
StoredDeclsMap * getLookupPtr() const
Retrieve the internal representation of the lookup structure.
DeclID getRawValue() const
A helper iterator adaptor to convert the iterators to SmallVector<SomeDeclID> to the iterators to Sma...
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
@ FOK_None
Not a friend object.
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
bool isFromExplicitGlobalModule() const
Whether this declaration comes from explicit global module.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
SourceLocation getLocation() const
DeclContext * getDeclContext()
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
GlobalDeclID getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
DeclarationNameLoc - Additional source/type location info for a declaration name.
SourceLocation getCXXLiteralOperatorNameLoc() const
Return the location of the literal operator name (without the operator keyword).
TypeSourceInfo * getNamedTypeInfo() const
Returns the source type info.
SourceRange getCXXOperatorNameRange() const
Return the range of the operator name (without the operator keyword).
The name of a declaration.
@ CXXConversionFunctionName
SourceLocation getDecltypeLoc() const
SourceLocation getRParenLoc() const
SourceLocation getTemplateNameLoc() const
Expr * getAttrExprOperand() const
The attribute's expression operand, if it has one.
SourceRange getAttrOperandParensRange() const
The location of the parentheses around the operand, if there is an operand.
SourceLocation getAttrNameLoc() const
The location of the attribute name, i.e.
NestedNameSpecifierLoc getQualifierLoc() const
SourceLocation getNameLoc() const
SourceLocation getElaboratedKeywordLoc() const
SourceLocation getNameLoc() const
unsigned getNumArgs() const
SourceLocation getTemplateNameLoc() const
SourceLocation getLAngleLoc() const
SourceLocation getTemplateKeywordLoc() const
TemplateArgumentLoc getArgLoc(unsigned i) const
SourceLocation getRAngleLoc() const
SourceLocation getElaboratedKeywordLoc() const
NestedNameSpecifierLoc getQualifierLoc() const
SourceLocation getNameLoc() const
static DiagnosticMapping getDefaultMapping(unsigned DiagID)
Get the default mapping for this diagnostic.
Options for controlling the compiler diagnostics engine.
std::vector< std::string > Remarks
The list of -R... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > Warnings
The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.
Concrete class used by the front-end to report problems and issues.
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).
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
SmallVector< SourceLocation, 64 > serializeSafeBufferOptOutMap() const
IdentifierTable & getIdentifierTable()
const LangOptions & getLangOpts() const
PreprocessingRecord * getPreprocessingRecord() const
Retrieve the preprocessing record, or NULL if there is no preprocessing record.
DiagnosticsEngine & getDiagnostics() const
SourceLocation getPreambleRecordedPragmaAssumeNonNullLoc() const
Get the location of the recorded unterminated #pragma clang assume_nonnull begin in the preamble,...
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
A (possibly-)qualified type.
Wrapper of type source information for a type with non-trivial direct qualifiers.
The collection of all-type qualifiers we support.
SourceLocation getAmpAmpLoc() const
Represents a struct/union/class.
Wrapper for source info for record types.
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.
Exposes information about the current target.
Options for controlling the target.
std::string Triple
The name of the target triple to compile for.
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
std::string ABI
If given, the name of the target ABI to use.
std::string TuneCPU
If given, the name of the target CPU to tune code for.
std::string CPU
If given, the name of the target CPU to generate code for.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line.
A template argument list.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
Location wrapper for a TemplateArgument.
TemplateArgumentLocInfo getLocInfo() const
const TemplateArgument & getArgument() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
ArgKind
The kind of template argument we're storing.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
SourceLocation getTemplateLoc() const
unsigned getNumArgs() const
SourceLocation getLAngleLoc() const
TemplateArgumentLoc getArgLoc(unsigned i) const
SourceLocation getRAngleLoc() const
SourceLocation getTemplateNameLoc() const
SourceLocation getTemplateKeywordLoc() const
Wrapper for template type parameters.
Token - This structure provides full information about a lexed token.
IdentifierInfo * getIdentifierInfo() const
unsigned getFlags() const
Return the internal represtation of the flags.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
unsigned getLength() const
SourceLocation getAnnotationEndLoc() const
void * getAnnotationValue() const
tok::TokenKind getKind() const
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
The top declaration context.
NamespaceDecl * getAnonymousNamespace() const
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
TypeSourceInfo * getUnmodifiedTInfo() const
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
SourceLocation getNameLoc() const
The base class of the type hierarchy.
TypeClass getTypeClass() const
Base class for declarations which introduce a typedef-name.
Wrapper for source info for typedefs.
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
SourceLocation getTypeofLoc() const
The iterator over UnresolvedSets.
Wrapper for source info for unresolved typename using decls.
Wrapper for source info for types used via transparent aliases.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
EvaluatedStmt * getEvaluatedStmt() const
const Expr * getInit() const
APValue * getEvaluatedValue() const
Return the already-evaluated value of this variable's initializer, or NULL if the value is not yet kn...
Declaration of a variable template.
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getNameLoc() const
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
SourceLocation getEllipsisLoc() const
Retrieve the source location of the ellipsis, whose presence indicates that the capture is a pack exp...
void writeQualifiers(Qualifiers value)
A key used when looking up entities by DeclarationName.
Information about a module that has been loaded by the ASTReader.
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
serialization::SelectorID BaseSelectorID
Base selector ID for selectors local to this module.
unsigned LocalNumSubmodules
The number of submodules in this module.
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
unsigned NumPreprocessedEntities
unsigned Index
The index of this module in the list of modules.
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
std::string FileName
The file name of the module file.
SourceLocation::UIntTy SLocEntryBaseOffset
The base offset in the source manager's view of this module.
unsigned LocalNumMacros
The number of macros in this AST file.
unsigned LocalNumSelectors
The number of selectors new to this file.
ModuleKind Kind
The type of this module.
std::string ModuleName
The name of the module.
serialization::MacroID BaseMacroID
Base macro ID for macros local to this module.
Manages the set of modules loaded by an AST reader.
Writer for the on-disk hash table.
A type index; the type ID with the qualifier bits removed.
uint32_t getModuleFileIndex() const
TypeID asTypeID(unsigned FastQuals) const
uint64_t getValue() 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.
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_EXPORT
An ExportDecl record.
@ DECL_PRAGMA_COMMENT
A PragmaCommentDecl record.
@ DECL_ENUM
An EnumDecl record.
@ DECL_OMP_DECLARE_REDUCTION
An OMPDeclareReductionDecl record.
@ DECL_OMP_THREADPRIVATE
An OMPThreadPrivateDecl record.
@ DECL_OBJC_METHOD
A ObjCMethodDecl record.
@ DECL_CXX_DESTRUCTOR
A CXXDestructorDecl record.
@ DECL_OMP_CAPTUREDEXPR
An OMPCapturedExprDecl record.
@ DECL_CLASS_TEMPLATE
A ClassTemplateDecl record.
@ DECL_USING_SHADOW
A UsingShadowDecl record.
@ DECL_CONCEPT
A ConceptDecl record.
@ DECL_OBJC_IVAR
A ObjCIvarDecl record.
@ DECL_OBJC_PROPERTY
A ObjCPropertyDecl record.
@ DECL_OBJC_INTERFACE
A ObjCInterfaceDecl record.
@ DECL_VAR_TEMPLATE
A VarTemplateDecl record.
@ DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION
A ClassTemplatePartialSpecializationDecl record.
@ DECL_CONTEXT_VISIBLE
A record that stores the set of declarations that are visible from a given DeclContext.
@ DECL_OBJC_PROPERTY_IMPL
A ObjCPropertyImplDecl record.
@ TYPE_EXT_QUAL
An ExtQualType record.
@ EXPR_DESIGNATED_INIT
A DesignatedInitExpr record.
@ EXPR_COMPOUND_LITERAL
A CompoundLiteralExpr record.
@ EXPR_OBJC_IVAR_REF_EXPR
An ObjCIvarRefExpr record.
@ EXPR_MEMBER
A MemberExpr record.
@ EXPR_CXX_TEMPORARY_OBJECT
A CXXTemporaryObjectExpr record.
@ EXPR_CXX_UNRESOLVED_LOOKUP
@ EXPR_COMPOUND_ASSIGN_OPERATOR
A CompoundAssignOperator record.
@ EXPR_EXPR_WITH_CLEANUPS
@ EXPR_CXX_STATIC_CAST
A CXXStaticCastExpr record.
@ EXPR_OBJC_STRING_LITERAL
An ObjCStringLiteral record.
@ EXPR_VA_ARG
A VAArgExpr record.
@ EXPR_CXX_OPERATOR_CALL
A CXXOperatorCallExpr record.
@ STMT_OBJC_AT_TRY
An ObjCAtTryStmt record.
@ EXPR_CXX_UNRESOLVED_CONSTRUCT
@ EXPR_FIXEDPOINT_LITERAL
@ STMT_DO
A DoStmt record.
@ STMT_OBJC_CATCH
An ObjCAtCatchStmt record.
@ STMT_IF
An IfStmt record.
@ EXPR_CXX_EXPRESSION_TRAIT
@ EXPR_STRING_LITERAL
A StringLiteral record.
@ EXPR_IMPLICIT_CAST
An ImplicitCastExpr record.
@ STMT_GCCASM
A GCC-style AsmStmt record.
@ EXPR_IMAGINARY_LITERAL
An ImaginaryLiteral record.
@ STMT_WHILE
A WhileStmt record.
@ EXPR_STMT
A StmtExpr record.
@ EXPR_CXX_REINTERPRET_CAST
A CXXReinterpretCastExpr record.
@ EXPR_DESIGNATED_INIT_UPDATE
A DesignatedInitUpdateExpr record.
@ STMT_OBJC_AT_SYNCHRONIZED
An ObjCAtSynchronizedStmt record.
@ EXPR_CXX_PSEUDO_DESTRUCTOR
@ EXPR_CHARACTER_LITERAL
A CharacterLiteral record.
@ EXPR_OBJC_ENCODE
An ObjCEncodeExpr record.
@ EXPR_CSTYLE_CAST
A CStyleCastExpr record.
@ EXPR_OBJC_BOXED_EXPRESSION
@ EXPR_OBJC_BOOL_LITERAL
An ObjCBoolLiteralExpr record.
@ EXPR_CXX_BIND_TEMPORARY
@ EXPR_EXT_VECTOR_ELEMENT
An ExtVectorElementExpr record.
@ STMT_RETURN
A ReturnStmt record.
@ STMT_OBJC_FOR_COLLECTION
An ObjCForCollectionStmt record.
@ STMT_CONTINUE
A ContinueStmt record.
@ EXPR_PREDEFINED
A PredefinedExpr record.
@ EXPR_CXX_BOOL_LITERAL
A CXXBoolLiteralExpr record.
@ EXPR_PAREN_LIST
A ParenListExpr record.
@ EXPR_CXX_PAREN_LIST_INIT
A CXXParenListInitExpr record.
@ STMT_COMPOUND
A CompoundStmt record.
@ STMT_FOR
A ForStmt record.
@ STMT_ATTRIBUTED
An AttributedStmt record.
@ EXPR_CXX_REWRITTEN_BINARY_OPERATOR
A CXXRewrittenBinaryOperator record.
@ STMT_GOTO
A GotoStmt record.
@ EXPR_NO_INIT
An NoInitExpr record.
@ EXPR_OBJC_ARRAY_LITERAL
@ EXPR_OBJC_PROTOCOL_EXPR
An ObjCProtocolExpr record.
@ EXPR_CXX_CONSTRUCT
A CXXConstructExpr record.
@ EXPR_OBJC_DICTIONARY_LITERAL
@ EXPR_CXX_DYNAMIC_CAST
A CXXDynamicCastExpr record.
@ STMT_CXX_TRY
A CXXTryStmt record.
@ EXPR_GENERIC_SELECTION
A GenericSelectionExpr record.
@ EXPR_CALL
A CallExpr record.
@ EXPR_GNU_NULL
A GNUNullExpr record.
@ EXPR_BINARY_CONDITIONAL_OPERATOR
@ EXPR_OBJC_PROPERTY_REF_EXPR
An ObjCPropertyRefExpr record.
@ EXPR_CXX_CONST_CAST
A CXXConstCastExpr record.
@ STMT_REF_PTR
A reference to a previously [de]serialized Stmt record.
@ EXPR_OBJC_MESSAGE_EXPR
An ObjCMessageExpr record.
@ EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
@ STMT_CASE
A CaseStmt record.
@ EXPR_FUNCTION_PARM_PACK
@ STMT_STOP
A marker record that indicates that we are at the end of an expression.
@ EXPR_CXX_NULL_PTR_LITERAL
@ STMT_MSASM
A MS-style AsmStmt record.
@ EXPR_CONDITIONAL_OPERATOR
A ConditionOperator record.
@ EXPR_BINARY_OPERATOR
A BinaryOperator record.
@ EXPR_CXX_STD_INITIALIZER_LIST
A CXXStdInitializerListExpr record.
@ EXPR_SHUFFLE_VECTOR
A ShuffleVectorExpr record.
@ STMT_OBJC_FINALLY
An ObjCAtFinallyStmt record.
@ EXPR_OBJC_SELECTOR_EXPR
An ObjCSelectorExpr record.
@ EXPR_FLOATING_LITERAL
A FloatingLiteral record.
@ EXPR_CXX_DEPENDENT_SCOPE_MEMBER
@ STMT_NULL_PTR
A NULL expression.
@ STMT_DEFAULT
A DefaultStmt record.
@ EXPR_CHOOSE
A ChooseExpr record.
@ STMT_NULL
A NullStmt record.
@ EXPR_DECL_REF
A DeclRefExpr record.
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM
@ EXPR_INIT_LIST
An InitListExpr record.
@ EXPR_IMPLICIT_VALUE_INIT
An ImplicitValueInitExpr record.
@ EXPR_PAREN
A ParenExpr record.
@ STMT_LABEL
A LabelStmt record.
@ EXPR_CXX_FUNCTIONAL_CAST
A CXXFunctionalCastExpr record.
@ EXPR_USER_DEFINED_LITERAL
A UserDefinedLiteral record.
@ EXPR_INTEGER_LITERAL
An IntegerLiteral record.
@ EXPR_MATERIALIZE_TEMPORARY
@ EXPR_CXX_MEMBER_CALL
A CXXMemberCallExpr record.
@ STMT_SWITCH
A SwitchStmt record.
@ STMT_DECL
A DeclStmt record.
@ EXPR_CXX_UNRESOLVED_MEMBER
@ EXPR_OBJC_KVC_REF_EXPR
UNUSED.
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
@ EXPR_CXX_SCALAR_VALUE_INIT
@ EXPR_SIZEOF_ALIGN_OF
A SizefAlignOfExpr record.
@ STMT_BREAK
A BreakStmt record.
@ STMT_OBJC_AT_THROW
An ObjCAtThrowStmt record.
@ EXPR_ADDR_LABEL
An AddrLabelExpr record.
@ STMT_CXX_FOR_RANGE
A CXXForRangeStmt record.
@ EXPR_CXX_ADDRSPACE_CAST
A CXXAddrspaceCastExpr record.
@ EXPR_ARRAY_SUBSCRIPT
An ArraySubscriptExpr record.
@ EXPR_UNARY_OPERATOR
A UnaryOperator record.
@ STMT_CXX_CATCH
A CXXCatchStmt record.
@ STMT_INDIRECT_GOTO
An IndirectGotoStmt record.
Defines the clang::TargetInfo interface.
bool isSystem(CharacteristicKind CK)
Determine whether a file / directory characteristic is for system code.
bool isModuleMap(CharacteristicKind CK)
Determine whether a file characteristic is for a module map.
bool LE(InterpState &S, CodePtr OpPC)
uint64_t TypeID
An ID number that refers to a type in an AST file.
@ EXTENSION_METADATA
Metadata describing this particular extension.
@ SUBMODULE_EXCLUDED_HEADER
Specifies a header that has been explicitly excluded from this submodule.
@ SUBMODULE_TOPHEADER
Specifies a top-level header that falls into this (sub)module.
@ SUBMODULE_PRIVATE_TEXTUAL_HEADER
Specifies a header that is private to this submodule but must be textually included.
@ SUBMODULE_HEADER
Specifies a header that falls into this (sub)module.
@ SUBMODULE_EXPORT_AS
Specifies the name of the module that will eventually re-export the entities in this module.
@ SUBMODULE_UMBRELLA_DIR
Specifies an umbrella directory.
@ SUBMODULE_UMBRELLA_HEADER
Specifies the umbrella header used to create this module, if any.
@ SUBMODULE_METADATA
Metadata for submodules as a whole.
@ SUBMODULE_REQUIRES
Specifies a required feature.
@ SUBMODULE_PRIVATE_HEADER
Specifies a header that is private to this submodule.
@ SUBMODULE_IMPORTS
Specifies the submodules that are imported by this submodule.
@ SUBMODULE_CONFLICT
Specifies a conflict with another module.
@ SUBMODULE_INITIALIZERS
Specifies some declarations with initializers that must be emitted to initialize the module.
@ SUBMODULE_DEFINITION
Defines the major attributes of a submodule, including its name and parent.
@ SUBMODULE_LINK_LIBRARY
Specifies a library or framework to link against.
@ SUBMODULE_CONFIG_MACRO
Specifies a configuration macro for this module.
@ SUBMODULE_EXPORTS
Specifies the submodules that are re-exported from this submodule.
@ SUBMODULE_TEXTUAL_HEADER
Specifies a header that is part of the module but must be textually included.
@ SUBMODULE_AFFECTING_MODULES
Specifies affecting modules that were not imported.
TypeIdx TypeIdxFromBuiltin(const BuiltinType *BT)
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
@ FILE_SYSTEM_OPTIONS
Record code for the filesystem options table.
@ TARGET_OPTIONS
Record code for the target options table.
@ PREPROCESSOR_OPTIONS
Record code for the preprocessor options table.
@ HEADER_SEARCH_OPTIONS
Record code for the headers search options table.
@ LANGUAGE_OPTIONS
Record code for the language options table.
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
@ SUBMODULE_BLOCK_ID
The block containing the submodule structure.
@ PREPROCESSOR_DETAIL_BLOCK_ID
The block containing the detailed preprocessing record.
@ AST_BLOCK_ID
The AST block, which acts as a container around the full AST block.
@ SOURCE_MANAGER_BLOCK_ID
The block containing information about the source manager.
@ CONTROL_BLOCK_ID
The control block, which contains all of the information that needs to be validated prior to committi...
@ DECLTYPES_BLOCK_ID
The block containing the definitions of all of the types and decls used within the AST file.
@ PREPROCESSOR_BLOCK_ID
The block containing information about the preprocessor.
@ COMMENTS_BLOCK_ID
The block containing comments.
@ UNHASHED_CONTROL_BLOCK_ID
A block with unhashed content.
@ EXTENSION_BLOCK_ID
A block containing a module file extension.
@ OPTIONS_BLOCK_ID
The block of configuration options, used to check that a module is being used in a configuration comp...
@ INPUT_FILES_BLOCK_ID
The block of input files, which were used as inputs to create this AST file.
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.
uint64_t IdentifierID
An ID number that refers to an identifier in an AST file.
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
@ DECL_UPDATE_OFFSETS
Record for offsets of DECL_UPDATES records for declarations that were modified after being deserializ...
@ STATISTICS
Record code for the extra statistics we gather while generating an AST file.
@ FLOAT_CONTROL_PRAGMA_OPTIONS
Record code for #pragma float_control options.
@ KNOWN_NAMESPACES
Record code for the set of known namespaces, which are used for typo correction.
@ SPECIAL_TYPES
Record code for the set of non-builtin, special types.
@ PENDING_IMPLICIT_INSTANTIATIONS
Record code for pending implicit instantiations.
@ TYPE_OFFSET
Record code for the offsets of each type.
@ DELEGATING_CTORS
The list of delegating constructor declarations.
@ PP_ASSUME_NONNULL_LOC
ID 66 used to be the list of included files.
@ EXT_VECTOR_DECLS
Record code for the set of ext_vector type names.
@ OPENCL_EXTENSIONS
Record code for enabled OpenCL extensions.
@ FP_PRAGMA_OPTIONS
Record code for floating point #pragma options.
@ PP_UNSAFE_BUFFER_USAGE
Record code for #pragma clang unsafe_buffer_usage begin/end.
@ 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.
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.
@ 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.
for(const auto &A :T->param_types())
const FunctionProtoType * T
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
@ None
The alignment was not explicit in code.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
Diagnostic wrappers for TextAPI types for error reporting.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
The signature of a module, which is a hash of the AST content.
static ASTFileSignature create(std::array< uint8_t, 20 > Bytes)
static ASTFileSignature createDummy()
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments.
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
const DeclarationNameLoc & getInfo() const
Structure used to store a statement, the constant value to which it was evaluated (if any),...
Contains a late templated function.
FPOptions FPO
Floating-point options in the point of definition.
Decl * D
The template function declaration to be late parsed.
Data for list of allocators.
a linked list of methods with the same selector name but different signatures.
ObjCMethodList * getNext() const
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
TemplateParameterList ** TemplParamLists
A new-allocated array of size NumTemplParamLists, containing pointers to the "outer" template paramet...
NestedNameSpecifierLoc QualifierLoc
unsigned NumTemplParamLists
The number of "outer" template parameter lists.
Location information for a TemplateArgument.
SourceLocation getTemplateEllipsisLoc() const
NestedNameSpecifierLoc getTemplateQualifierLoc() const
TypeSourceInfo * getAsTypeSourceInfo() const
SourceLocation getTemplateNameLoc() const
Describes the categories of an Objective-C class.