74 #include "llvm/ADT/APFloat.h"
75 #include "llvm/ADT/APInt.h"
76 #include "llvm/ADT/APSInt.h"
77 #include "llvm/ADT/ArrayRef.h"
78 #include "llvm/ADT/DenseMap.h"
79 #include "llvm/ADT/Hashing.h"
80 #include "llvm/ADT/Optional.h"
81 #include "llvm/ADT/PointerIntPair.h"
82 #include "llvm/ADT/STLExtras.h"
83 #include "llvm/ADT/ScopeExit.h"
84 #include "llvm/ADT/SmallPtrSet.h"
85 #include "llvm/ADT/SmallString.h"
86 #include "llvm/ADT/SmallVector.h"
87 #include "llvm/ADT/StringMap.h"
88 #include "llvm/ADT/StringRef.h"
89 #include "llvm/Bitstream/BitCodes.h"
90 #include "llvm/Bitstream/BitstreamWriter.h"
91 #include "llvm/Support/Casting.h"
92 #include "llvm/Support/Compression.h"
93 #include "llvm/Support/DJB.h"
94 #include "llvm/Support/Endian.h"
95 #include "llvm/Support/EndianStream.h"
96 #include "llvm/Support/Error.h"
97 #include "llvm/Support/ErrorHandling.h"
98 #include "llvm/Support/LEB128.h"
99 #include "llvm/Support/MemoryBuffer.h"
100 #include "llvm/Support/OnDiskHashTable.h"
101 #include "llvm/Support/Path.h"
102 #include "llvm/Support/SHA1.h"
103 #include "llvm/Support/VersionTuple.h"
104 #include "llvm/Support/raw_ostream.h"
119 using namespace clang;
122 template <
typename T,
typename Allocator>
123 static StringRef
bytes(
const std::vector<T, Allocator> &
v) {
124 if (
v.empty())
return StringRef();
125 return StringRef(
reinterpret_cast<const char*
>(&
v[0]),
126 sizeof(T) *
v.size());
129 template <
typename T>
131 return StringRef(
reinterpret_cast<const char*
>(
v.data()),
132 sizeof(T) *
v.size());
137 Str.reserve(
V.size() / 8);
138 for (
unsigned I = 0, E =
V.size(); I < E;) {
140 for (
unsigned Bit = 0; Bit < 8 && I < E; ++Bit, ++I)
153 #define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
154 case Type::CLASS_ID: return TYPE_##CODE_ID;
155 #include "clang/Serialization/TypeBitCodes.def"
157 llvm_unreachable(
"shouldn't be serializing a builtin type this way");
159 llvm_unreachable(
"bad type kind");
164 std::set<const FileEntry *> GetAllModuleMaps(
const HeaderSearch &HS,
166 std::set<const FileEntry *> ModuleMaps{};
167 std::set<const Module *> ProcessedModules;
176 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
189 ModulesToProcess.push_back(KH.getModule());
193 while (!ModulesToProcess.empty()) {
194 auto *CurrentModule = ModulesToProcess.pop_back_val();
195 ProcessedModules.insert(CurrentModule);
197 auto *ModuleMapFile =
199 if (!ModuleMapFile) {
203 ModuleMaps.insert(ModuleMapFile);
205 for (
auto *ImportedModule : (CurrentModule)->Imports) {
206 if (!ImportedModule ||
207 ProcessedModules.find(ImportedModule) != ProcessedModules.end()) {
210 ModulesToProcess.push_back(ImportedModule);
214 if (UndeclaredModule &&
215 ProcessedModules.find(UndeclaredModule) == ProcessedModules.end())
216 ModulesToProcess.push_back(UndeclaredModule);
222 class ASTTypeWriter {
229 : Writer(Writer), BasicWriter(Writer, Record) {}
260 : Record(Record), Seq(Seq) {}
262 #define ABSTRACT_TYPELOC(CLASS, PARENT)
263 #define TYPELOC(CLASS, PARENT) \
264 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
265 #include "clang/AST/TypeLocNodes.def"
320 void TypeLocWriter::VisitArrayTypeLoc(
ArrayTypeLoc TL) {
329 VisitArrayTypeLoc(TL);
333 VisitArrayTypeLoc(TL);
337 VisitArrayTypeLoc(TL);
340 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
342 VisitArrayTypeLoc(TL);
345 void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
349 addSourceLocation(
range.getBegin());
350 addSourceLocation(
range.getEnd());
354 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
363 void TypeLocWriter::VisitDependentVectorTypeLoc(
375 addSourceLocation(
range.getBegin());
376 addSourceLocation(
range.getEnd());
381 void TypeLocWriter::VisitDependentSizedMatrixTypeLoc(
385 addSourceLocation(
range.getBegin());
386 addSourceLocation(
range.getEnd());
397 for (
unsigned i = 0, e = TL.
getNumParams(); i != e; ++i)
402 VisitFunctionTypeLoc(TL);
406 VisitFunctionTypeLoc(TL);
413 void TypeLocWriter::VisitUsingTypeLoc(
UsingTypeLoc TL) {
455 void TypeLocWriter::VisitAutoTypeLoc(
AutoTypeLoc TL) {
465 for (
unsigned I = 0; I < TL.
getNumArgs(); ++I)
474 void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
483 void TypeLocWriter::VisitEnumTypeLoc(
EnumTypeLoc TL) {
499 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
504 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
509 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
515 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
520 void TypeLocWriter::VisitParenTypeLoc(
ParenTypeLoc TL) {
544 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
552 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I)
587 void TypeLocWriter::VisitPipeTypeLoc(
PipeTypeLoc TL) {
594 void TypeLocWriter::VisitDependentBitIntTypeLoc(
599 void ASTWriter::WriteTypeAbbrevs() {
600 using namespace llvm;
602 std::shared_ptr<BitCodeAbbrev> Abv;
605 Abv = std::make_shared<BitCodeAbbrev>();
607 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
608 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3));
609 TypeExtQualAbbrev = Stream.EmitAbbrev(std::move(Abv));
617 llvm::BitstreamWriter &Stream,
620 Record.push_back(
ID);
621 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
624 if (!Name || Name[0] == 0)
628 Record.push_back(*Name++);
629 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
633 llvm::BitstreamWriter &Stream,
636 Record.push_back(
ID);
638 Record.push_back(*Name++);
639 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
644 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
774 void ASTWriter::WriteBlockInfoBlock() {
776 Stream.EnterBlockInfoBlock();
778 #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
779 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
782 BLOCK(CONTROL_BLOCK);
793 BLOCK(OPTIONS_BLOCK);
800 BLOCK(INPUT_FILES_BLOCK);
863 BLOCK(SOURCE_MANAGER_BLOCK);
871 BLOCK(PREPROCESSOR_BLOCK);
879 BLOCK(SUBMODULE_BLOCK);
900 BLOCK(COMMENTS_BLOCK);
904 BLOCK(DECLTYPES_BLOCK);
908 RECORD(TYPE_BLOCK_POINTER);
909 RECORD(TYPE_LVALUE_REFERENCE);
910 RECORD(TYPE_RVALUE_REFERENCE);
911 RECORD(TYPE_MEMBER_POINTER);
912 RECORD(TYPE_CONSTANT_ARRAY);
913 RECORD(TYPE_INCOMPLETE_ARRAY);
914 RECORD(TYPE_VARIABLE_ARRAY);
917 RECORD(TYPE_FUNCTION_NO_PROTO);
918 RECORD(TYPE_FUNCTION_PROTO);
924 RECORD(TYPE_OBJC_INTERFACE);
925 RECORD(TYPE_OBJC_OBJECT_POINTER);
928 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
929 RECORD(TYPE_UNRESOLVED_USING);
930 RECORD(TYPE_INJECTED_CLASS_NAME);
932 RECORD(TYPE_TEMPLATE_TYPE_PARM);
933 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
934 RECORD(TYPE_DEPENDENT_NAME);
935 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
936 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
938 RECORD(TYPE_MACRO_QUALIFIED);
939 RECORD(TYPE_PACK_EXPANSION);
941 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
943 RECORD(TYPE_UNARY_TRANSFORM);
947 RECORD(TYPE_OBJC_TYPE_PARAM);
1024 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
1030 BLOCK(EXTENSION_BLOCK);
1033 BLOCK(UNHASHED_CONTROL_BLOCK);
1051 return Changed | llvm::sys::path::remove_dots(Path);
1066 assert(
Filename &&
"No file name to adjust?");
1068 if (BaseDir.empty())
1073 for (;
Filename[Pos] && Pos < BaseDir.size(); ++Pos)
1083 if (!llvm::sys::path::is_separator(
Filename[Pos])) {
1084 if (!llvm::sys::path::is_separator(BaseDir.back()))
1101 std::pair<ASTFileSignature, ASTFileSignature>
1102 ASTWriter::createSignature(StringRef AllBytes, StringRef ASTBlockBytes) {
1104 Hasher.update(ASTBlockBytes);
1110 AllBytes.take_front(ASTBlockBytes.bytes_end() - AllBytes.bytes_begin()));
1112 AllBytes.take_back(AllBytes.bytes_end() - ASTBlockBytes.bytes_end()));
1115 return std::make_pair(ASTBlockHash, Signature);
1120 using namespace llvm;
1123 Stream.FlushToWord();
1124 auto StartOfUnhashedControl = Stream.GetCurrentBitNo() >> 3;
1132 if (WritingModule &&
1135 auto ASTBlockStartByte = ASTBlockRange.first >> 3;
1136 auto ASTBlockByteLength = (ASTBlockRange.second >> 3) - ASTBlockStartByte;
1137 std::tie(ASTBlockHash, Signature) = createSignature(
1138 StringRef(Buffer.begin(), StartOfUnhashedControl),
1139 StringRef(Buffer.begin() + ASTBlockStartByte, ASTBlockByteLength));
1141 Record.append(ASTBlockHash.begin(), ASTBlockHash.end());
1144 Record.append(Signature.begin(), Signature.end());
1152 #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1153 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1154 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1155 #include "clang/Basic/DiagnosticOptions.def"
1156 Record.push_back(DiagOpts.
Warnings.size());
1157 for (
unsigned I = 0, N = DiagOpts.
Warnings.size(); I != N; ++I)
1158 AddString(DiagOpts.
Warnings[I], Record);
1159 Record.push_back(DiagOpts.
Remarks.size());
1160 for (
unsigned I = 0, N = DiagOpts.
Remarks.size(); I != N; ++I)
1161 AddString(DiagOpts.
Remarks[I], Record);
1168 WritePragmaDiagnosticMappings(Diags, WritingModule);
1172 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1174 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1175 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1176 unsigned HSUsageAbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1179 HSEntryUsage.size()};
1180 Stream.EmitRecordWithBlob(HSUsageAbbrevCode, Record,
bytes(HSEntryUsage));
1192 using namespace llvm;
1198 auto MetadataAbbrev = std::make_shared<BitCodeAbbrev>();
1199 MetadataAbbrev->Add(BitCodeAbbrevOp(
METADATA));
1200 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1201 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1202 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1203 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16));
1204 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1205 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1206 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1207 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1208 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev));
1209 assert((!WritingModule || isysroot.empty()) &&
1210 "writing module as a relocatable PCH?");
1212 RecordData::value_type Record[] = {
1216 CLANG_VERSION_MAJOR,
1217 CLANG_VERSION_MINOR,
1220 ASTHasCompilerErrors};
1221 Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record,
1225 if (WritingModule) {
1227 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1229 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1230 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1232 Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name);
1235 if (WritingModule && WritingModule->Directory) {
1241 BaseDir.assign(CWD->getName());
1243 BaseDir.assign(WritingModule->Directory->getName());
1254 WritingModule->Directory->getName() != StringRef(
".")) {
1256 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1258 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1259 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1262 Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir);
1266 BaseDirectory.assign(BaseDir.begin(), BaseDir.end());
1267 }
else if (!isysroot.empty()) {
1277 AddPath(WritingModule->PresumedModuleMapFile.empty()
1278 ? Map.getModuleMapFileForUniquing(WritingModule)->getName()
1279 : StringRef(WritingModule->PresumedModuleMapFile),
1283 if (
auto *AdditionalModMaps =
1284 Map.getAdditionalModuleMapFiles(WritingModule)) {
1285 Record.push_back(AdditionalModMaps->size());
1286 for (
const FileEntry *F : *AdditionalModMaps)
1287 AddPath(F->getName(), Record);
1289 Record.push_back(0);
1302 if (!M.isDirectlyImported())
1305 Record.push_back((
unsigned)M.Kind);
1306 AddSourceLocation(M.ImportLoc, Record);
1310 Record.push_back(M.Signature ? 0 : M.File->getSize());
1311 Record.push_back(M.Signature ? 0 : getTimestampForOutput(M.File));
1313 llvm::append_range(Record, M.Signature);
1315 AddString(M.ModuleName, Record);
1316 AddPath(M.FileName, Record);
1318 Stream.EmitRecord(
IMPORTS, Record);
1327 #define LANGOPT(Name, Bits, Default, Description) \
1328 Record.push_back(LangOpts.Name);
1329 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1330 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1331 #include "clang/Basic/LangOptions.def"
1332 #define SANITIZER(NAME, ID) \
1333 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID));
1334 #include "clang/Basic/Sanitizers.def"
1338 AddString(Feature, Record);
1348 AddString(I, Record);
1355 AddString(T.getTriple(), Record);
1365 AddString(TargetOpts.
Triple, Record);
1366 AddString(TargetOpts.
CPU, Record);
1367 AddString(TargetOpts.
TuneCPU, Record);
1368 AddString(TargetOpts.
ABI, Record);
1373 Record.push_back(TargetOpts.
Features.size());
1374 for (
unsigned I = 0, N = TargetOpts.
Features.size(); I != N; ++I) {
1375 AddString(TargetOpts.
Features[I], Record);
1390 AddString(HSOpts.
Sysroot, Record);
1394 for (
unsigned I = 0, N = HSOpts.
UserEntries.size(); I != N; ++I) {
1396 AddString(Entry.
Path, Record);
1397 Record.push_back(
static_cast<unsigned>(Entry.
Group));
1429 Record.push_back(PPOpts.
Macros.size());
1430 for (
unsigned I = 0, N = PPOpts.
Macros.size(); I != N; ++I) {
1431 AddString(PPOpts.
Macros[I].first, Record);
1432 Record.push_back(PPOpts.
Macros[I].second);
1436 Record.push_back(PPOpts.
Includes.size());
1437 for (
unsigned I = 0, N = PPOpts.
Includes.size(); I != N; ++I)
1438 AddString(PPOpts.
Includes[I], Record);
1442 for (
unsigned I = 0, N = PPOpts.
MacroIncludes.size(); I != N; ++I)
1457 if (
const FileEntry *MainFile =
SM.getFileEntryForID(
SM.getMainFileID())) {
1458 auto FileAbbrev = std::make_shared<BitCodeAbbrev>();
1460 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1461 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1462 unsigned FileAbbrevCode = Stream.EmitAbbrev(std::move(FileAbbrev));
1466 Record.push_back(
SM.getMainFileID().getOpaqueValue());
1467 EmitRecordWithPath(FileAbbrevCode, Record, MainFile->getName());
1471 Record.push_back(
SM.getMainFileID().getOpaqueValue());
1475 if (!OutputFile.empty() && OutputFile !=
"-") {
1476 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1478 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1479 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
1482 PreparePathForOutput(OutputPath);
1483 StringRef origDir = llvm::sys::path::parent_path(OutputPath);
1486 Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
1489 std::set<const FileEntry *> AffectingModuleMaps;
1490 if (WritingModule) {
1491 AffectingModuleMaps =
1495 WriteInputFiles(Context.SourceMgr,
1497 AffectingModuleMaps);
1504 struct InputFileEntry {
1508 bool BufferOverridden;
1509 bool IsTopLevelModuleMap;
1510 uint32_t ContentHash[2];
1515 void ASTWriter::WriteInputFiles(
1517 std::set<const FileEntry *> &AffectingModuleMaps) {
1518 using namespace llvm;
1523 auto IFAbbrev = std::make_shared<BitCodeAbbrev>();
1525 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1526 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12));
1527 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
1528 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1529 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1530 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1531 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1532 unsigned IFAbbrevCode = Stream.EmitAbbrev(std::move(IFAbbrev));
1535 auto IFHAbbrev = std::make_shared<BitCodeAbbrev>();
1537 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1538 IFHAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1539 unsigned IFHAbbrevCode = Stream.EmitAbbrev(std::move(IFHAbbrev));
1543 std::deque<InputFileEntry> SortedFiles;
1547 assert(&SourceMgr.
getSLocEntry(FileID::get(I)) == SLoc);
1554 if (!
Cache->OrigEntry)
1559 !AffectingModuleMaps.empty() &&
1560 AffectingModuleMaps.find(
Cache->OrigEntry) ==
1561 AffectingModuleMaps.end()) {
1562 SkippedModuleMaps.insert(
Cache->OrigEntry);
1567 InputFileEntry Entry;
1568 Entry.File =
Cache->OrigEntry;
1569 Entry.IsSystemFile =
isSystem(
File.getFileCharacteristic());
1570 Entry.IsTransient =
Cache->IsTransient;
1571 Entry.BufferOverridden =
Cache->BufferOverridden;
1572 Entry.IsTopLevelModuleMap =
isModuleMap(
File.getFileCharacteristic()) &&
1573 File.getIncludeLoc().isInvalid();
1575 auto ContentHash = hash_code(-1);
1579 auto MemBuff =
Cache->getBufferIfLoaded();
1581 ContentHash =
hash_value(MemBuff->getBuffer());
1585 << Entry.File->getName();
1588 Entry.ContentHash[0] =
1589 static_cast<uint32_t
>(CH.getLoBits(32).getZExtValue());
1590 Entry.ContentHash[1] =
1591 static_cast<uint32_t
>(CH.getHiBits(32).getZExtValue());
1593 if (Entry.IsSystemFile)
1594 SortedFiles.push_back(Entry);
1596 SortedFiles.push_front(Entry);
1599 unsigned UserFilesNum = 0;
1601 std::vector<uint64_t> InputFileOffsets;
1602 for (
const auto &Entry : SortedFiles) {
1603 uint32_t &InputFileID = InputFileIDs[Entry.File];
1604 if (InputFileID != 0)
1608 InputFileOffsets.push_back(Stream.GetCurrentBitNo());
1610 InputFileID = InputFileOffsets.size();
1612 if (!Entry.IsSystemFile)
1618 RecordData::value_type Record[] = {
1620 InputFileOffsets.size(),
1621 (uint64_t)Entry.File->getSize(),
1622 (uint64_t)getTimestampForOutput(Entry.File),
1623 Entry.BufferOverridden,
1625 Entry.IsTopLevelModuleMap};
1628 EmitRecordWithPath(IFAbbrevCode, Record, Entry.File->getName());
1633 RecordData::value_type Record[] = {
INPUT_FILE_HASH, Entry.ContentHash[0],
1634 Entry.ContentHash[1]};
1635 Stream.EmitRecordWithAbbrev(IFHAbbrevCode, Record);
1642 auto OffsetsAbbrev = std::make_shared<BitCodeAbbrev>();
1644 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1645 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1647 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1648 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(std::move(OffsetsAbbrev));
1652 InputFileOffsets.size(), UserFilesNum};
1653 Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record,
bytes(InputFileOffsets));
1663 using namespace llvm;
1665 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1667 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1668 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1669 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1670 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1672 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1673 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1674 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24));
1675 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1676 return Stream.EmitAbbrev(std::move(Abbrev));
1682 using namespace llvm;
1684 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1686 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1687 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1688 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
1689 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1690 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1691 return Stream.EmitAbbrev(std::move(Abbrev));
1698 using namespace llvm;
1700 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1704 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1705 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1706 return Stream.EmitAbbrev(std::move(Abbrev));
1712 using namespace llvm;
1714 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1716 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1717 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
1718 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1719 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1720 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1721 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1722 return Stream.EmitAbbrev(std::move(Abbrev));
1727 static std::pair<unsigned, unsigned>
1729 llvm::encodeULEB128(KeyLen, Out);
1730 llvm::encodeULEB128(DataLen, Out);
1731 return std::make_pair(KeyLen, DataLen);
1737 class HeaderFileInfoTrait {
1742 llvm::StringMap<unsigned> FrameworkNameOffset;
1745 HeaderFileInfoTrait(
ASTWriter &Writer) : Writer(Writer) {}
1752 using key_type_ref =
const key_type &;
1754 using UnresolvedModule =
1755 llvm::PointerIntPair<Module *, 2, ModuleMap::ModuleHeaderRole>;
1762 using data_type_ref =
const data_type &;
1774 std::pair<unsigned, unsigned>
1775 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) {
1776 unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
1777 unsigned DataLen = 1 + 4 + 4;
1778 for (
auto ModInfo : Data.KnownHeaders)
1781 if (Data.Unresolved.getPointer())
1786 void EmitKey(raw_ostream& Out, key_type_ref key,
unsigned KeyLen) {
1787 using namespace llvm::support;
1789 endian::Writer
LE(Out, little);
1790 LE.write<uint64_t>(key.Size);
1792 LE.write<uint64_t>(key.ModTime);
1794 Out.write(key.Filename.data(), KeyLen);
1797 void EmitData(raw_ostream &Out, key_type_ref key,
1798 data_type_ref Data,
unsigned DataLen) {
1799 using namespace llvm::support;
1801 endian::Writer
LE(Out, little);
1802 uint64_t Start = Out.tell(); (void)Start;
1804 unsigned char Flags = (Data.HFI.isImport << 5)
1805 | (Data.HFI.isPragmaOnce << 4)
1806 | (Data.HFI.DirInfo << 1)
1807 | Data.HFI.IndexHeaderMapHeader;
1808 LE.write<uint8_t>(Flags);
1810 if (!Data.HFI.ControllingMacro)
1811 LE.write<uint32_t>(Data.HFI.ControllingMacroID);
1816 if (!Data.HFI.Framework.empty()) {
1818 llvm::StringMap<unsigned>::iterator Pos
1819 = FrameworkNameOffset.find(Data.HFI.Framework);
1820 if (Pos == FrameworkNameOffset.end()) {
1821 Offset = FrameworkStringData.size() + 1;
1822 FrameworkStringData.append(Data.HFI.Framework);
1823 FrameworkStringData.push_back(0);
1825 FrameworkNameOffset[Data.HFI.Framework] =
Offset;
1833 uint32_t
Value = (ModID << 2) | (
unsigned)Role;
1834 assert((
Value >> 2) == ModID &&
"overflow in header module info");
1841 for (
auto ModInfo : Data.KnownHeaders)
1842 EmitModule(ModInfo.getModule(), ModInfo.getRole());
1843 if (Data.Unresolved.getPointer())
1844 EmitModule(Data.Unresolved.getPointer(), Data.Unresolved.getInt());
1846 assert(Out.tell() - Start == DataLen &&
"Wrong data length");
1849 const char *strings_begin()
const {
return FrameworkStringData.begin(); }
1850 const char *strings_end()
const {
return FrameworkStringData.end(); }
1858 void ASTWriter::WriteHeaderSearch(
const HeaderSearch &HS) {
1859 HeaderFileInfoTrait GeneratorTrait(*
this);
1860 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait>
Generator;
1862 unsigned NumHeaderSearchEntries = 0;
1869 if (WritingModule) {
1871 while (!Worklist.empty()) {
1872 Module *M = Worklist.pop_back_val();
1889 if (!
U.Size || (!
U.ModTime && IncludeTimestamps)) {
1890 PP->
Diag(
U.FileNameLoc, diag::err_module_no_size_mtime_for_header)
1891 << WritingModule->getFullModuleName() <<
U.Size.hasValue()
1898 llvm::sys::path::append(
Filename,
U.FileName);
1901 StringRef FilenameDup = strdup(
Filename.c_str());
1902 SavedStrings.push_back(FilenameDup.data());
1904 HeaderFileInfoTrait::key_type Key = {
1905 FilenameDup, *
U.Size, IncludeTimestamps ? *
U.ModTime : 0
1907 HeaderFileInfoTrait::data_type Data = {
1912 Generator.insert(Key, Data, GeneratorTrait);
1913 ++NumHeaderSearchEntries;
1926 for (
unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
1945 if (PreparePathForOutput(FilenameTmp)) {
1948 Filename = StringRef(strdup(FilenameTmp.c_str()));
1949 SavedStrings.push_back(
Filename.data());
1952 HeaderFileInfoTrait::key_type Key = {
1955 HeaderFileInfoTrait::data_type Data = {
1958 Generator.insert(Key, Data, GeneratorTrait);
1959 ++NumHeaderSearchEntries;
1964 uint32_t BucketOffset;
1966 using namespace llvm::support;
1968 llvm::raw_svector_ostream Out(TableData);
1970 endian::write<uint32_t>(Out, 0, little);
1971 BucketOffset =
Generator.Emit(Out, GeneratorTrait);
1975 using namespace llvm;
1977 auto Abbrev = std::make_shared<BitCodeAbbrev>();
1979 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1980 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1981 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1982 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1983 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
1987 NumHeaderSearchEntries, TableData.size()};
1988 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
1989 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData);
1992 for (
unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
1993 free(
const_cast<char *
>(SavedStrings[I]));
1996 static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob,
1997 unsigned SLocBufferBlobCompressedAbbrv,
1998 unsigned SLocBufferBlobAbbrv) {
1999 using RecordDataType = ASTWriter::RecordData::value_type;
2004 if (llvm::zlib::isAvailable()) {
2005 llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer);
2007 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record,
2013 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob);
2024 void ASTWriter::WriteSourceManagerBlock(
SourceManager &SourceMgr,
2030 const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo();
2036 unsigned SLocBufferBlobCompressedAbbrv =
2042 std::vector<uint32_t> SLocEntryOffsets;
2043 uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo();
2044 RecordData PreloadSLocs;
2050 FileID FID = FileID::get(I);
2054 uint64_t
Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;
2055 assert((
Offset >> 32) == 0 &&
"SLocEntry offset too large");
2056 SLocEntryOffsets.push_back(
Offset);
2062 if (
Cache->OrigEntry) {
2069 Record.push_back(Code);
2072 Record.push_back(SLoc->
getOffset() - 2);
2076 if (Content->
OrigEntry && !SkippedModuleMaps.empty() &&
2077 SkippedModuleMaps.find(Content->
OrigEntry) !=
2078 SkippedModuleMaps.end()) {
2082 AddSourceLocation(
File.getIncludeLoc(), Record);
2083 Record.push_back(
File.getFileCharacteristic());
2084 Record.push_back(
File.hasLineDirectives());
2086 bool EmitBlob =
false;
2089 "Writing to AST an overridden file is not supported");
2092 assert(InputFileIDs[Content->
OrigEntry] != 0 &&
"Missed file entry");
2093 Record.push_back(InputFileIDs[Content->
OrigEntry]);
2095 Record.push_back(
File.NumCreatedFIDs);
2097 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
2098 if (FDI != FileDeclIDs.end()) {
2099 Record.push_back(FDI->second->FirstDeclIndex);
2100 Record.push_back(FDI->second->DeclIDs.size());
2102 Record.push_back(0);
2103 Record.push_back(0);
2106 Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record);
2119 StringRef Name = Buffer ? Buffer->getBufferIdentifier() :
"";
2120 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
2121 StringRef(Name.data(), Name.size() + 1));
2124 if (Name ==
"<built-in>")
2125 PreloadSLocs.push_back(SLocEntryOffsets.size());
2134 Buffer = llvm::MemoryBufferRef(
"<<<INVALID BUFFER>>>",
"");
2135 StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1);
2136 emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv,
2137 SLocBufferBlobAbbrv);
2155 Record.push_back(NextOffset - SLoc->
getOffset() - 1);
2156 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
2162 if (SLocEntryOffsets.empty())
2167 using namespace llvm;
2169 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2171 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2172 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16));
2173 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2174 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2175 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2177 RecordData::value_type Record[] = {
2180 SLocEntryOffsetsBase - SourceManagerBlockOffset};
2181 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record,
2182 bytes(SLocEntryOffsets));
2196 llvm::DenseMap<int, int> FilenameMap;
2197 FilenameMap[-1] = -1;
2198 for (
const auto &L : LineTable) {
2201 for (
auto &
LE : L.second) {
2202 if (FilenameMap.insert(std::make_pair(
LE.FilenameID,
2203 FilenameMap.size() - 1)).second)
2204 AddPath(LineTable.getFilename(
LE.FilenameID), Record);
2207 Record.push_back(0);
2210 for (
const auto &L : LineTable) {
2216 Record.push_back(L.first.ID);
2219 Record.push_back(L.second.size());
2220 for (
const auto &
LE : L.second) {
2221 Record.push_back(
LE.FileOffset);
2222 Record.push_back(
LE.LineNo);
2223 Record.push_back(FilenameMap[
LE.FilenameID]);
2224 Record.push_back((
unsigned)
LE.FileKind);
2225 Record.push_back(
LE.IncludeOffset);
2240 if (MI->isBuiltinMacro())
2254 void ASTWriter::writeIncludedFiles(raw_ostream &Out,
const Preprocessor &PP) {
2255 using namespace llvm::support;
2259 std::vector<uint32_t> IncludedInputFileIDs;
2260 IncludedInputFileIDs.reserve(IncludedFiles.size());
2262 for (
const FileEntry *File : IncludedFiles) {
2263 auto InputFileIt = InputFileIDs.find(File);
2264 if (InputFileIt == InputFileIDs.end())
2266 IncludedInputFileIDs.push_back(InputFileIt->second);
2269 llvm::sort(IncludedInputFileIDs);
2271 endian::Writer
LE(Out, little);
2272 LE.write<uint32_t>(IncludedInputFileIDs.size());
2273 for (uint32_t
ID : IncludedInputFileIDs)
2274 LE.write<uint32_t>(
ID);
2279 void ASTWriter::WritePreprocessor(
const Preprocessor &PP,
bool IsModule) {
2280 uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo();
2284 WritePreprocessorDetail(*PPRec, MacroOffsetsBase);
2287 RecordData ModuleMacroRecord;
2299 if (AssumeNonNullLoc.
isValid()) {
2301 AddSourceLocation(AssumeNonNullLoc, Record);
2309 if (SkipInfo.hasValue()) {
2310 Record.push_back(
true);
2311 AddSourceLocation(SkipInfo->HashTokenLoc, Record);
2312 AddSourceLocation(SkipInfo->IfTokenLoc, Record);
2313 Record.push_back(SkipInfo->FoundNonSkipPortion);
2314 Record.push_back(SkipInfo->FoundElse);
2315 AddSourceLocation(SkipInfo->ElseLoc, Record);
2317 Record.push_back(
false);
2320 AddSourceLocation(Cond.IfLoc, Record);
2321 Record.push_back(Cond.WasSkipping);
2322 Record.push_back(Cond.FoundNonSkip);
2323 Record.push_back(Cond.FoundElse);
2344 if (
Id.second->hadMacroDefinition() &&
2345 (!
Id.second->isFromAST() ||
2346 Id.second->hasChangedSinceDeserialization()))
2347 MacroIdentifiers.push_back(
Id.second);
2350 llvm::sort(MacroIdentifiers,
llvm::deref<std::less<>>());
2356 uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2357 assert((StartOffset >> 32) == 0 &&
"Macro identifiers offset too large");
2360 bool EmittedModuleMacros =
false;
2368 if (IsModule && WritingModule->isHeaderUnit()) {
2376 Record.push_back(MD->
getKind());
2377 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2378 Record.push_back(getMacroRef(DefMD->getInfo(), Name));
2379 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2380 Record.push_back(VisMD->isPublic());
2382 ModuleMacroRecord.push_back(getSubmoduleID(WritingModule));
2383 ModuleMacroRecord.push_back(getMacroRef(MD->
getMacroInfo(), Name));
2385 ModuleMacroRecord.clear();
2386 EmittedModuleMacros =
true;
2395 Record.push_back(MD->
getKind());
2396 if (
auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2397 Record.push_back(getMacroRef(DefMD->getInfo(), Name));
2398 }
else if (
auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2399 Record.push_back(VisMD->isPublic());
2406 llvm::DenseMap<ModuleMacro *, unsigned> Visits;
2407 while (!Worklist.empty()) {
2408 auto *
Macro = Worklist.pop_back_val();
2411 ModuleMacroRecord.push_back(getSubmoduleID(
Macro->getOwningModule()));
2412 ModuleMacroRecord.push_back(getMacroRef(
Macro->getMacroInfo(), Name));
2413 for (
auto *M :
Macro->overrides())
2414 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));
2417 ModuleMacroRecord.clear();
2420 for (
auto *M :
Macro->overrides())
2421 if (++Visits[M] == M->getNumOverridingMacros())
2422 Worklist.push_back(M);
2424 EmittedModuleMacros =
true;
2427 if (Record.empty() && !EmittedModuleMacros)
2430 IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2441 std::vector<uint32_t> MacroOffsets;
2443 for (
unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2448 if (
ID < FirstMacroID) {
2449 assert(0 &&
"Loaded MacroInfo entered MacroInfosToEmit ?");
2454 unsigned Index =
ID - FirstMacroID;
2455 if (Index >= MacroOffsets.size())
2456 MacroOffsets.resize(Index + 1);
2458 uint64_t
Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2459 assert((
Offset >> 32) == 0 &&
"Macro offset too large");
2460 MacroOffsets[Index] =
Offset;
2462 AddIdentifierRef(Name, Record);
2465 Record.push_back(MI->
isUsed());
2479 AddIdentifierRef(Param, Record);
2487 Stream.EmitRecord(Code, Record);
2491 for (
unsigned TokNo = 0, e = MI->
getNumTokens(); TokNo != e; ++TokNo) {
2496 AddToken(Tok, Record);
2497 Stream.EmitRecord(
PP_TOKEN, Record);
2506 using namespace llvm;
2508 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2510 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2511 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2512 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32));
2513 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2515 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2517 RecordData::value_type Record[] = {
MACRO_OFFSET, MacroOffsets.size(),
2519 MacroOffsetsBase - ASTBlockStartOffset};
2520 Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record,
bytes(MacroOffsets));
2524 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2526 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2527 unsigned IncludedFilesAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2530 raw_svector_ostream Out(Buffer);
2531 writeIncludedFiles(Out, PP);
2533 Stream.EmitRecordWithBlob(IncludedFilesAbbrev, Record, Buffer.data(),
2539 uint64_t MacroOffsetsBase) {
2549 unsigned NumPreprocessingRecords = 0;
2550 using namespace llvm;
2553 unsigned InclusionAbbrev = 0;
2555 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2557 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2558 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2559 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
2560 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2561 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2562 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2565 unsigned FirstPreprocessorEntityID
2566 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2568 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
2573 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
2576 uint64_t
Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
2577 assert((
Offset >> 32) == 0 &&
"Preprocessed entity offset too large");
2578 PreprocessedEntityOffsets.push_back(
2581 if (
auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) {
2583 MacroDefinitions[MD] = NextPreprocessorEntityID;
2585 AddIdentifierRef(MD->getName(), Record);
2590 if (
auto *ME = dyn_cast<MacroExpansion>(*E)) {
2591 Record.push_back(ME->isBuiltinMacro());
2592 if (ME->isBuiltinMacro())
2593 AddIdentifierRef(ME->getName(), Record);
2595 Record.push_back(MacroDefinitions[ME->getDefinition()]);
2600 if (
auto *
ID = dyn_cast<InclusionDirective>(*E)) {
2602 Record.push_back(
ID->getFileName().size());
2603 Record.push_back(
ID->wasInQuotes());
2604 Record.push_back(
static_cast<unsigned>(
ID->getKind()));
2605 Record.push_back(
ID->importedModule());
2607 Buffer +=
ID->getFileName();
2611 Buffer +=
ID->getFile()->getName();
2612 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer);
2616 llvm_unreachable(
"Unhandled PreprocessedEntity in ASTWriter");
2621 if (NumPreprocessingRecords > 0) {
2622 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2625 using namespace llvm;
2627 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2629 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2630 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2631 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2634 FirstPreprocessorEntityID -
2636 Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record,
2637 bytes(PreprocessedEntityOffsets));
2642 if (SkippedRanges.size() > 0) {
2643 std::vector<PPSkippedRange> SerializedSkippedRanges;
2644 SerializedSkippedRanges.reserve(SkippedRanges.size());
2645 for (
auto const& Range : SkippedRanges)
2646 SerializedSkippedRanges.emplace_back(Range);
2648 using namespace llvm;
2649 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2651 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2652 unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2656 Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev, Record,
2657 bytes(SerializedSkippedRanges));
2665 auto Known = SubmoduleIDs.find(Mod);
2666 if (Known != SubmoduleIDs.end())
2667 return Known->second;
2670 if (Top != WritingModule &&
2671 (getLangOpts().CompilingPCH ||
2672 !Top->fullModuleNameIs(StringRef(getLangOpts().CurrentModule))))
2675 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2678 unsigned ASTWriter::getSubmoduleID(
Module *Mod) {
2682 unsigned ID = getLocalOrImportedSubmoduleID(Mod);
2683 assert((
ID || !Mod) &&
2684 "asked for module ID for non-local, non-imported module");
2691 unsigned ChildModules = 0;
2696 return ChildModules + 1;
2699 void ASTWriter::WriteSubmodules(
Module *WritingModule) {
2704 using namespace llvm;
2706 auto Abbrev = std::make_shared<BitCodeAbbrev>();
2708 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2709 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2710 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
2711 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2712 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2713 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2714 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2715 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2716 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2717 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2718 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2719 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2720 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2721 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2723 Abbrev = std::make_shared<BitCodeAbbrev>();
2725 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2726 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2728 Abbrev = std::make_shared<BitCodeAbbrev>();
2730 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2731 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2733 Abbrev = std::make_shared<BitCodeAbbrev>();
2735 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2736 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2738 Abbrev = std::make_shared<BitCodeAbbrev>();
2740 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2741 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2743 Abbrev = std::make_shared<BitCodeAbbrev>();
2745 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2746 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2747 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2749 Abbrev = std::make_shared<BitCodeAbbrev>();
2751 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2752 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2754 Abbrev = std::make_shared<BitCodeAbbrev>();
2756 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2757 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2759 Abbrev = std::make_shared<BitCodeAbbrev>();
2761 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2762 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2764 Abbrev = std::make_shared<BitCodeAbbrev>();
2766 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2767 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2769 Abbrev = std::make_shared<BitCodeAbbrev>();
2771 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2772 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2773 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2775 Abbrev = std::make_shared<BitCodeAbbrev>();
2777 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2778 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2780 Abbrev = std::make_shared<BitCodeAbbrev>();
2782 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2783 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2784 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2786 Abbrev = std::make_shared<BitCodeAbbrev>();
2788 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2789 unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
2792 RecordData::value_type Record[] = {
2798 std::queue<Module *> Q;
2799 Q.push(WritingModule);
2800 while (!Q.empty()) {
2803 unsigned ID = getSubmoduleID(Mod);
2805 uint64_t ParentID = 0;
2807 assert(SubmoduleIDs[Mod->
Parent] &&
"Submodule parent not written?");
2808 ParentID = SubmoduleIDs[Mod->
Parent];
2816 (RecordData::value_type)Mod->
Kind,
2826 Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->
Name);
2832 Stream.EmitRecordWithBlob(RequiresAbbrev, Record, R.first);
2838 Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record,
2839 UmbrellaHeader.NameAsWritten);
2842 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record,
2843 UmbrellaDir.NameAsWritten);
2848 unsigned RecordKind;
2859 for (
auto &HL : HeaderLists) {
2860 RecordData::value_type Record[] = {HL.RecordKind};
2861 for (
auto &H : Mod->
Headers[HL.HeaderKind])
2862 Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten);
2869 for (
auto *H : TopHeaders) {
2871 PreparePathForOutput(HeaderName);
2872 Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, HeaderName);
2880 Record.push_back(getSubmoduleID(I));
2887 for (
const auto &E : Mod->
Exports) {
2890 Record.push_back(getSubmoduleID(E.getPointer()));
2891 Record.push_back(E.getInt());
2906 Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, LL.Library);
2914 getSubmoduleID(
C.Other)};
2915 Stream.EmitRecordWithBlob(ConflictAbbrev, Record,
C.Message);
2921 Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, CM);
2927 Inits.push_back(GetDeclRef(D));
2934 Stream.EmitRecordWithBlob(ExportAsAbbrev, Record, Mod->
ExportAsModule);
2944 assert((NextSubmoduleID - FirstSubmoduleID ==
2946 "Wrong # of submodules; found a reference to a non-local, "
2947 "non-imported submodule?");
2952 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
2954 unsigned CurrID = 0;
2957 auto EncodeDiagStateFlags =
2958 [](
const DiagnosticsEngine::DiagState *DS) ->
unsigned {
2959 unsigned Result = (
unsigned)DS->ExtBehavior;
2961 {(
unsigned)DS->IgnoreAllWarnings, (
unsigned)DS->EnableAllWarnings,
2962 (
unsigned)DS->WarningsAsErrors, (
unsigned)DS->ErrorsAsFatal,
2963 (
unsigned)DS->SuppressSystemWarnings})
2964 Result = (Result << 1) | Val;
2968 unsigned Flags = EncodeDiagStateFlags(
Diag.DiagStatesByLoc.FirstDiagState);
2969 Record.push_back(Flags);
2971 auto AddDiagState = [&](
const DiagnosticsEngine::DiagState *
State,
2972 bool IncludeNonPragmaStates) {
2975 assert(Flags == EncodeDiagStateFlags(
State) &&
2976 "diag state flags vary in single AST file");
2978 unsigned &DiagStateID = DiagStateIDMap[
State];
2979 Record.push_back(DiagStateID);
2981 if (DiagStateID == 0) {
2982 DiagStateID = ++CurrID;
2985 auto SizeIdx = Record.size();
2986 Record.emplace_back();
2987 for (
const auto &I : *
State) {
2988 if (I.second.isPragma() || IncludeNonPragmaStates) {
2989 Record.push_back(I.first);
2990 Record.push_back(I.second.serialize());
2994 Record[SizeIdx] = (Record.size() - SizeIdx) / 2;
2998 AddDiagState(
Diag.DiagStatesByLoc.FirstDiagState, isModule);
3001 auto NumLocationsIdx = Record.size();
3002 Record.emplace_back();
3005 unsigned NumLocations = 0;
3006 for (
auto &FileIDAndFile :
Diag.DiagStatesByLoc.Files) {
3007 if (!FileIDAndFile.first.isValid() ||
3008 !FileIDAndFile.second.HasLocalTransitions)
3013 assert(!Loc.
isInvalid() &&
"start loc for valid FileID is invalid");
3014 AddSourceLocation(Loc, Record);
3016 Record.push_back(FileIDAndFile.second.StateTransitions.size());
3017 for (
auto &StatePoint : FileIDAndFile.second.StateTransitions) {
3018 Record.push_back(StatePoint.Offset);
3019 AddDiagState(StatePoint.State,
false);
3024 Record[NumLocationsIdx] = NumLocations;
3032 AddSourceLocation(
Diag.DiagStatesByLoc.CurDiagStateLoc, Record);
3033 AddDiagState(
Diag.DiagStatesByLoc.CurDiagState,
false);
3043 void ASTWriter::WriteType(
QualType T) {
3044 TypeIdx &IdxRef = TypeIdxs[T];
3046 IdxRef =
TypeIdx(NextTypeID++);
3049 assert(Idx.
getIndex() >= FirstTypeID &&
"Re-writing a type from a prior AST");
3052 uint64_t
Offset = ASTTypeWriter(*this).write(T) - DeclTypesBlockStartOffset;
3055 unsigned Index = Idx.
getIndex() - FirstTypeID;
3056 if (TypeOffsets.size() == Index)
3057 TypeOffsets.emplace_back(
Offset);
3058 else if (TypeOffsets.size() < Index) {
3059 TypeOffsets.resize(Index + 1);
3060 TypeOffsets[Index].setBitOffset(
Offset);
3062 llvm_unreachable(
"Types emitted in wrong order");
3075 uint64_t ASTWriter::WriteDeclContextLexicalBlock(
ASTContext &Context,
3080 uint64_t
Offset = Stream.GetCurrentBitNo();
3082 for (
const auto *D : DC->
decls()) {
3083 KindDeclPairs.push_back(D->getKind());
3084 KindDeclPairs.push_back(GetDeclRef(D));
3087 ++NumLexicalDeclContexts;
3089 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record,
3090 bytes(KindDeclPairs));
3094 void ASTWriter::WriteTypeDeclOffsets() {
3095 using namespace llvm;
3098 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3100 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3101 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3102 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3103 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3105 RecordData::value_type Record[] = {
TYPE_OFFSET, TypeOffsets.size(),
3107 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record,
bytes(TypeOffsets));
3111 Abbrev = std::make_shared<BitCodeAbbrev>();
3113 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3114 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3115 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3116 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3118 RecordData::value_type Record[] = {
DECL_OFFSET, DeclOffsets.size(),
3120 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record,
bytes(DeclOffsets));
3124 void ASTWriter::WriteFileDeclIDsMap() {
3125 using namespace llvm;
3128 SortedFileDeclIDs.reserve(FileDeclIDs.size());
3129 for (
const auto &
P : FileDeclIDs)
3130 SortedFileDeclIDs.push_back(std::make_pair(
P.first,
P.second.get()));
3131 llvm::sort(SortedFileDeclIDs, llvm::less_first());
3135 for (
auto &FileDeclEntry : SortedFileDeclIDs) {
3136 DeclIDInFileInfo &Info = *FileDeclEntry.second;
3137 Info.FirstDeclIndex = FileGroupedDeclIDs.size();
3138 llvm::stable_sort(Info.DeclIDs);
3139 for (
auto &LocDeclEntry : Info.DeclIDs)
3140 FileGroupedDeclIDs.push_back(LocDeclEntry.second);
3143 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3145 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3146 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3147 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev));
3149 FileGroupedDeclIDs.size()};
3150 Stream.EmitRecordWithBlob(AbbrevCode, Record,
bytes(FileGroupedDeclIDs));
3153 void ASTWriter::WriteComments() {
3155 auto _ = llvm::make_scope_exit([
this] { Stream.ExitBlock(); });
3159 for (
const auto &FO : Context->
Comments.OrderedComments) {
3160 for (
const auto &OC : FO.second) {
3164 Record.push_back(I->
getKind());
3179 class ASTMethodPoolTrait {
3184 using key_type_ref = key_type;
3190 using data_type_ref =
const data_type &;
3195 explicit ASTMethodPoolTrait(
ASTWriter &Writer) : Writer(Writer) {}
3201 std::pair<unsigned, unsigned>
3202 EmitKeyDataLength(raw_ostream& Out,
Selector Sel,
3203 data_type_ref Methods) {
3205 unsigned DataLen = 4 + 2 + 2;
3208 if (ShouldWriteMethodListNode(Method))
3212 if (ShouldWriteMethodListNode(Method))
3217 void EmitKey(raw_ostream& Out,
Selector Sel,
unsigned) {
3218 using namespace llvm::support;
3220 endian::Writer
LE(Out, little);
3221 uint64_t Start = Out.tell();
3222 assert((Start >> 32) == 0 &&
"Selector key offset too large");
3225 LE.write<uint16_t>(N);
3228 for (
unsigned I = 0; I != N; ++I)
3233 void EmitData(raw_ostream& Out, key_type_ref,
3234 data_type_ref Methods,
unsigned DataLen) {
3235 using namespace llvm::support;
3237 endian::Writer
LE(Out, little);
3238 uint64_t Start = Out.tell(); (void)Start;
3239 LE.write<uint32_t>(Methods.ID);
3240 unsigned NumInstanceMethods = 0;
3243 if (ShouldWriteMethodListNode(Method))
3244 ++NumInstanceMethods;
3246 unsigned NumFactoryMethods = 0;
3249 if (ShouldWriteMethodListNode(Method))
3250 ++NumFactoryMethods;
3252 unsigned InstanceBits = Methods.Instance.getBits();
3253 assert(InstanceBits < 4);
3254 unsigned InstanceHasMoreThanOneDeclBit =
3255 Methods.Instance.hasMoreThanOneDecl();
3256 unsigned FullInstanceBits = (NumInstanceMethods << 3) |
3257 (InstanceHasMoreThanOneDeclBit << 2) |
3259 unsigned FactoryBits = Methods.Factory.getBits();
3260 assert(FactoryBits < 4);
3261 unsigned FactoryHasMoreThanOneDeclBit =
3262 Methods.Factory.hasMoreThanOneDecl();
3263 unsigned FullFactoryBits = (NumFactoryMethods << 3) |
3264 (FactoryHasMoreThanOneDeclBit << 2) |
3266 LE.write<uint16_t>(FullInstanceBits);
3267 LE.write<uint16_t>(FullFactoryBits);
3270 if (ShouldWriteMethodListNode(Method))
3271 LE.write<uint32_t>(Writer.
getDeclID(Method->getMethod()));
3274 if (ShouldWriteMethodListNode(Method))
3275 LE.write<uint32_t>(Writer.
getDeclID(Method->getMethod()));
3277 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
3282 return (
Node->getMethod() && !
Node->getMethod()->isFromASTFile());
3293 void ASTWriter::WriteSelectors(
Sema &SemaRef) {
3294 using namespace llvm;
3299 unsigned NumTableEntries = 0;
3302 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait>
Generator;
3303 ASTMethodPoolTrait Trait(*
this);
3307 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
3308 for (
auto &SelectorAndID : SelectorIDs) {
3312 ASTMethodPoolTrait::data_type Data = {
3318 Data.Instance = F->second.first;
3319 Data.Factory = F->second.second;
3323 if (Chain &&
ID < FirstSelectorID) {
3325 bool changed =
false;
3328 if (!M->getMethod()->isFromASTFile()) {
3336 if (!M->getMethod()->isFromASTFile()) {
3344 }
else if (Data.Instance.getMethod() || Data.Factory.getMethod()) {
3353 uint32_t BucketOffset;
3355 using namespace llvm::support;
3357 ASTMethodPoolTrait Trait(*
this);
3358 llvm::raw_svector_ostream Out(MethodPool);
3360 endian::write<uint32_t>(Out, 0, little);
3361 BucketOffset =
Generator.Emit(Out, Trait);
3365 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3367 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3368 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3369 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3370 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3374 RecordData::value_type Record[] = {
METHOD_POOL, BucketOffset,
3376 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool);
3380 Abbrev = std::make_shared<BitCodeAbbrev>();
3382 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3383 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3384 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3385 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3389 RecordData::value_type Record[] = {
3392 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
3393 bytes(SelectorOffsets));
3399 void ASTWriter::WriteReferencedSelectorsPool(
Sema &SemaRef) {
3400 using namespace llvm;
3412 Selector Sel = SelectorAndLocation.first;
3414 Writer.AddSelectorRef(Sel);
3436 for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
3438 if (!Redecl->isFromASTFile()) {
3442 if (!Redecl->getDeclContext()->getRedeclContext()->Equals(
3445 return cast<NamedDecl>(Redecl);
3450 if (Redecl->getOwningModuleID() == 0)
3455 if (!
First->isFromASTFile())
3456 return cast<NamedDecl>(
First);
3466 class ASTIdentifierTableTrait {
3490 using key_type_ref = key_type;
3493 using data_type_ref = data_type;
3501 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule),
3502 NeedDecls(!IsModule || !Writer.getLangOpts().
CPlusPlus),
3503 InterestingIdentifierOffsets(InterestingIdentifierOffsets) {}
3505 bool needDecls()
const {
return NeedDecls; }
3508 return llvm::djbHash(II->
getName());
3520 std::pair<unsigned, unsigned>
3529 InterestingIdentifierOffsets->push_back(Out.tell());
3532 unsigned DataLen = 4;
3542 DEnd = IdResolver.
end();
3557 using namespace llvm::support;
3559 endian::Writer
LE(Out, little);
3563 LE.write<uint32_t>(
ID << 1);
3567 LE.write<uint32_t>((
ID << 1) | 0x01);
3569 assert((Bits & 0xffff) == Bits &&
"ObjCOrBuiltinID too big for ASTReader.");
3570 LE.write<uint16_t>(Bits);
3572 bool HadMacroDefinition = MacroOffset != 0;
3573 Bits = (Bits << 1) |
unsigned(HadMacroDefinition);
3575 Bits = (Bits << 1) |
unsigned(II->
isPoisoned());
3578 LE.write<uint16_t>(Bits);
3580 if (HadMacroDefinition)
3581 LE.write<uint32_t>(MacroOffset);
3592 for (
NamedDecl *D : llvm::reverse(Decls))
3609 using namespace llvm;
3611 RecordData InterestingIdents;
3616 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait>
Generator;
3617 ASTIdentifierTableTrait Trait(
3618 *
this, PP, IdResolver, IsModule,
3619 (getLangOpts().
CPlusPlus && IsModule) ? &InterestingIdents :
nullptr);
3628 IIs.push_back(
ID.second);
3633 if (Trait.isInterestingNonMacroIdentifier(II))
3634 getIdentifierRef(II);
3638 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
3639 for (
auto IdentIDPair : IdentifierIDs) {
3642 assert(II &&
"NULL identifier in identifier table");
3645 if (
ID >= FirstIdentID || !Chain || !II->
isFromAST()
3647 (Trait.needDecls() &&
3654 uint32_t BucketOffset;
3656 using namespace llvm::support;
3660 endian::write<uint32_t>(Out, 0, little);
3661 BucketOffset =
Generator.Emit(Out, Trait);
3665 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3667 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3668 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3669 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3677 auto Abbrev = std::make_shared<BitCodeAbbrev>();
3679 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3680 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3681 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3682 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
3685 for (
unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
3686 assert(IdentifierOffsets[I] &&
"Missing identifier offset?");
3690 IdentifierOffsets.size(),
3692 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
3693 bytes(IdentifierOffsets));
3697 if (!InterestingIdents.empty())
3708 class ASTDeclContextNameLookupTrait {
3714 using key_type_ref = key_type;
3717 using data_type = std::pair<unsigned, unsigned>;
3718 using data_type_ref =
const data_type &;
3723 explicit ASTDeclContextNameLookupTrait(
ASTWriter &Writer) : Writer(Writer) {}
3725 template<
typename Coll>
3726 data_type getData(
const Coll &Decls) {
3727 unsigned Start = DeclIDs.size();
3732 return std::make_pair(Start, DeclIDs.size());
3736 unsigned Start = DeclIDs.size();
3737 llvm::append_range(DeclIDs, FromReader);
3738 return std::make_pair(Start, DeclIDs.size());
3741 static bool EqualKey(key_type_ref a, key_type_ref
b) {
3746 return Name.getHash();
3749 void EmitFileRef(raw_ostream &Out,
ModuleFile *F)
const {
3751 "have reference to loaded module file but no chain?");
3753 using namespace llvm::support;
3758 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
3760 data_type_ref Lookup) {
3761 unsigned KeyLen = 1;
3762 switch (Name.getKind()) {
3782 unsigned DataLen = 4 * (Lookup.second - Lookup.first);
3788 using namespace llvm::support;
3790 endian::Writer
LE(Out, little);
3791 LE.write<uint8_t>(Name.getKind());
3792 switch (Name.getKind()) {
3805 "Invalid operator?");
3806 LE.write<uint8_t>(Name.getOperatorKind());
3815 llvm_unreachable(
"Invalid name kind?");
3818 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
3820 using namespace llvm::support;
3822 endian::Writer
LE(Out, little);
3823 uint64_t Start = Out.tell(); (void)Start;
3824 for (
unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
3825 LE.write<uint32_t>(DeclIDs[I]);
3826 assert(Out.tell() - Start == DataLen &&
"Data length is wrong");
3834 return Result.hasExternalDecls() &&
3835 DC->hasNeedToReconcileExternalVisibleStorage();
3838 bool ASTWriter::isLookupResultEntirelyExternal(
StoredDeclsList &Result,
3840 for (
auto *D : Result.getLookupResult())
3848 ASTWriter::GenerateNameLookupTable(
const DeclContext *ConstDC,
3850 assert(!ConstDC->hasLazyLocalLexicalLookups() &&
3851 !ConstDC->hasLazyExternalLexicalLookups() &&
3852 "must call buildLookups first");
3860 ASTDeclContextNameLookupTrait>
Generator;
3861 ASTDeclContextNameLookupTrait Trait(*
this);
3873 auto &Name = Lookup.first;
3874 auto &Result = Lookup.second;
3880 if (isLookupResultExternal(Result, DC) &&
3881 isLookupResultEntirelyExternal(Result, DC))
3898 if (Lookup.second.getLookupResult().empty())
3901 switch (Lookup.first.getNameKind()) {
3903 Names.push_back(Lookup.first);
3907 assert(isa<CXXRecordDecl>(DC) &&
3908 "Cannot have a constructor name outside of a class!");
3909 ConstructorNameSet.insert(Name);
3913 assert(isa<CXXRecordDecl>(DC) &&
3914 "Cannot have a conversion function name outside of a class!");
3915 ConversionNameSet.insert(Name);
3923 if (
auto *D = dyn_cast<CXXRecordDecl>(DC)) {
3937 if (ConstructorNameSet.erase(ImplicitCtorName))
3938 Names.push_back(ImplicitCtorName);
3943 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty())
3944 for (
Decl *ChildD : cast<CXXRecordDecl>(DC)->decls())
3945 if (
auto *ChildND = dyn_cast<NamedDecl>(ChildD)) {
3946 auto Name = ChildND->getDeclName();
3947 switch (Name.getNameKind()) {
3952 if (ConstructorNameSet.erase(Name))
3953 Names.push_back(Name);
3957 if (ConversionNameSet.erase(Name))
3958 Names.push_back(Name);
3962 if (ConstructorNameSet.empty() && ConversionNameSet.empty())
3966 assert(ConstructorNameSet.empty() &&
"Failed to find all of the visible "
3967 "constructors by walking all the "
3968 "lexical members of the context.");
3969 assert(ConversionNameSet.empty() &&
"Failed to find all of the visible "
3970 "conversion functions by walking all "
3971 "the lexical members of the context.");
3978 for (
auto &Name : Names)
3990 for (
auto &Name : Names) {
3993 switch (Name.getNameKind()) {
3995 Generator.insert(Name, Trait.getData(Result), Trait);
3999 ConstructorDecls.append(Result.begin(), Result.end());
4003 ConversionDecls.append(Result.begin(), Result.end());
4011 if (!ConstructorDecls.empty())
4012 Generator.insert(ConstructorDecls.front()->getDeclName(),
4013 Trait.getData(ConstructorDecls), Trait);
4014 if (!ConversionDecls.empty())
4015 Generator.insert(ConversionDecls.front()->getDeclName(),
4016 Trait.getData(ConversionDecls), Trait);
4020 auto *Lookups = Chain ? Chain->getLoadedLookupTables(DC) :
nullptr;
4021 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table :
nullptr);
4029 uint64_t ASTWriter::WriteDeclContextVisibleBlock(
ASTContext &Context,
4034 if (isa<NamespaceDecl>(DC) && Chain &&
4035 Chain->getKeyDeclaration(cast<Decl>(DC))->isFromASTFile()) {
4037 for (
auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;
4038 Prev = Prev->getPreviousDecl())
4039 if (!Prev->isFromASTFile())
4052 LookupResults.reserve(Map->size());
4053 for (
auto &Entry : *Map)
4054 LookupResults.push_back(
4055 std::make_pair(Entry.first, Entry.second.getLookupResult()));
4058 llvm::sort(LookupResults, llvm::less_first());
4059 for (
auto &NameAndResult : LookupResults) {
4067 assert(Result.empty() &&
"Cannot have a constructor or conversion "
4068 "function name in a namespace!");
4073 if (!ND->isFromASTFile())
4097 uint64_t
Offset = Stream.GetCurrentBitNo();
4099 if (!Map || Map->empty())
4104 GenerateNameLookupTable(DC, LookupTable);
4108 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
4110 ++NumVisibleDeclContexts;
4120 void ASTWriter::WriteDeclContextVisibleUpdate(
const DeclContext *DC) {
4122 if (!Map || Map->empty())
4127 GenerateNameLookupTable(DC, LookupTable);
4131 if (isa<NamespaceDecl>(DC))
4132 DC = cast<DeclContext>(Chain->getKeyDeclaration(cast<Decl>(DC)));
4135 RecordData::value_type Record[] = {
UPDATE_VISIBLE, getDeclID(cast<Decl>(DC))};
4136 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable);
4146 void ASTWriter::WriteOpenCLExtensions(
Sema &SemaRef) {
4152 for (
const auto &I:Opts.OptMap) {
4153 AddString(I.getKey(), Record);
4154 auto V = I.getValue();
4155 Record.push_back(
V.Supported ? 1 : 0);
4156 Record.push_back(
V.Enabled ? 1 : 0);
4157 Record.push_back(
V.WithPragma ? 1 : 0);
4158 Record.push_back(
V.Avail);
4159 Record.push_back(
V.Core);
4160 Record.push_back(
V.Opt);
4164 void ASTWriter::WriteCUDAPragmas(
Sema &SemaRef) {
4165 if (SemaRef.ForceCUDAHostDeviceDepth > 0) {
4166 RecordData::value_type Record[] = {SemaRef.ForceCUDAHostDeviceDepth};
4171 void ASTWriter::WriteObjCCategories() {
4173 RecordData Categories;
4175 for (
unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
4177 unsigned StartIndex = Categories.size();
4182 Categories.push_back(0);
4186 Cat =
Class->known_categories_begin(),
4187 CatEnd =
Class->known_categories_end();
4188 Cat != CatEnd; ++Cat, ++Size) {
4189 assert(getDeclID(*Cat) != 0 &&
"Bogus category");
4190 AddDeclRef(*Cat, Categories);
4194 Categories[StartIndex] =
Size;
4198 CategoriesMap.push_back(CatInfo);
4203 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
4206 using namespace llvm;
4208 auto Abbrev = std::make_shared<BitCodeAbbrev>();
4210 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
4211 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4212 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
4215 Stream.EmitRecordWithBlob(AbbrevID, Record,
4216 reinterpret_cast<char *
>(CategoriesMap.data()),
4223 void ASTWriter::WriteLateParsedTemplates(
Sema &SemaRef) {
4230 for (
auto &LPTMapEntry : LPTMap) {
4233 AddDeclRef(FD, Record);
4234 AddDeclRef(LPT.
D, Record);
4235 Record.push_back(LPT.
Toks.size());
4237 for (
const auto &Tok : LPT.
Toks) {
4238 AddToken(Tok, Record);
4245 void ASTWriter::WriteOptimizePragmaOptions(
Sema &SemaRef) {
4248 AddSourceLocation(PragmaLoc, Record);
4253 void ASTWriter::WriteMSStructPragmaOptions(
Sema &SemaRef) {
4261 void ASTWriter::WriteMSPointersToMembersPragmaOptions(
Sema &SemaRef) {
4269 void ASTWriter::WritePackPragmaOptions(
Sema &SemaRef) {
4277 AddSourceLocation(SemaRef.
AlignPackStack.CurrentPragmaLocation, Record);
4280 AddAlignPackInfo(StackEntry.Value, Record);
4281 AddSourceLocation(StackEntry.PragmaLocation, Record);
4282 AddSourceLocation(StackEntry.PragmaPushLocation, Record);
4283 AddString(StackEntry.StackSlotLabel, Record);
4289 void ASTWriter::WriteFloatControlPragmaOptions(
Sema &SemaRef) {
4296 Record.push_back(SemaRef.
FpPragmaStack.CurrentValue.getAsOpaqueInt());
4297 AddSourceLocation(SemaRef.
FpPragmaStack.CurrentPragmaLocation, Record);
4299 for (
const auto &StackEntry : SemaRef.
FpPragmaStack.Stack) {
4300 Record.push_back(StackEntry.Value.getAsOpaqueInt());
4301 AddSourceLocation(StackEntry.PragmaLocation, Record);
4302 AddSourceLocation(StackEntry.PragmaPushLocation, Record);
4303 AddString(StackEntry.StackSlotLabel, Record);
4308 void ASTWriter::WriteModuleFileExtension(
Sema &SemaRef,
4314 auto Abv = std::make_shared<llvm::BitCodeAbbrev>();
4316 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4317 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4318 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4319 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4320 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4321 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv));
4327 Record.push_back(Metadata.MajorVersion);
4328 Record.push_back(Metadata.MinorVersion);
4329 Record.push_back(Metadata.BlockName.size());
4330 Record.push_back(Metadata.UserInfo.size());
4332 Buffer += Metadata.BlockName;
4333 Buffer += Metadata.UserInfo;
4334 Stream.EmitRecordWithBlob(Abbrev, Record, Buffer);
4348 auto &Record = *
this;
4350 return Record.push_back(0);
4351 Record.push_back(A->
getKind() + 1);
4355 Record.AddSourceRange(A->
getRange());
4359 Record.push_back(A->getAttributeSpellingListIndexRaw());
4361 #include "clang/Serialization/AttrPCHWrite.inc"
4366 push_back(Attrs.size());
4367 for (
const auto *A : Attrs)
4379 Record.push_back(Tok.
getKind());
4385 Record.push_back(Str.size());
4386 Record.insert(Record.end(), Str.begin(), Str.end());
4390 assert(Context &&
"should have context when outputting path");
4396 const char *PathBegin = Path.data();
4397 const char *PathPtr =
4399 if (PathPtr != PathBegin) {
4400 Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin));
4409 PreparePathForOutput(FilePath);
4410 AddString(FilePath, Record);
4416 PreparePathForOutput(FilePath);
4417 Stream.EmitRecordWithBlob(Abbrev, Record, FilePath);
4422 Record.push_back(Version.getMajor());
4424 Record.push_back(*Minor + 1);
4426 Record.push_back(0);
4428 Record.push_back(*Subminor + 1);
4430 Record.push_back(0);
4439 if (
ID >= FirstIdentID)
4440 IdentifierOffsets[
ID - FirstIdentID] =
Offset;
4446 unsigned ID = SelectorIDs[Sel];
4447 assert(
ID &&
"Unknown selector");
4450 if (
ID < FirstSelectorID)
4452 SelectorOffsets[
ID - FirstSelectorID] =
Offset;
4458 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
4459 bool IncludeTimestamps)
4460 : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),
4461 IncludeTimestamps(IncludeTimestamps) {
4462 for (
const auto &Ext : Extensions) {
4463 if (
auto Writer = Ext->createExtensionWriter(*
this))
4464 ModuleFileExtensionWriters.push_back(std::move(Writer));
4471 assert(WritingAST &&
"can't determine lang opts when not writing AST");
4481 Module *WritingModule, StringRef isysroot,
4483 bool ShouldCacheASTInMemory) {
4486 ASTHasCompilerErrors = hasErrors;
4489 Stream.Emit((
unsigned)
'C', 8);
4490 Stream.Emit((
unsigned)
'P', 8);
4491 Stream.Emit((
unsigned)
'C', 8);
4492 Stream.Emit((
unsigned)
'H', 8);
4494 WriteBlockInfoBlock();
4498 this->WritingModule = WritingModule;
4500 WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule);
4503 this->WritingModule =
nullptr;
4504 this->BaseDirectory.clear();
4507 if (ShouldCacheASTInMemory) {
4510 llvm::MemoryBuffer::getMemBufferCopy(
4511 StringRef(Buffer.begin(), Buffer.size())));
4516 template<
typename Vector>
4519 for (
typename Vector::iterator I = Vec.begin(
nullptr,
true), E = Vec.end();
4528 using namespace llvm;
4530 bool isModule = WritingModule !=
nullptr;
4534 Chain->finalizeForWriting();
4551 RegisterPredefDecl(Context.ObjCProtocolClassDecl,
4555 RegisterPredefDecl(Context.ObjCInstanceTypeDecl,
4559 RegisterPredefDecl(Context.BuiltinMSVaListDecl,
4564 RegisterPredefDecl(Context.MakeIntegerSeqDecl,
4566 RegisterPredefDecl(Context.CFConstantStringTypeDecl,
4568 RegisterPredefDecl(Context.CFConstantStringTagDecl,
4570 RegisterPredefDecl(Context.TypePackElementDecl,
4583 UnusedFileScopedDecls);
4595 for (
const auto &WeakUndeclaredIdentifierList :
4597 const IdentifierInfo *
const II = WeakUndeclaredIdentifierList.first;
4598 for (
const auto &WI : WeakUndeclaredIdentifierList.second) {
4612 for (
unsigned I = 0, N = SemaRef.
VTableUses.size(); I != N; ++I) {
4622 AddDeclRef(TD, UnusedLocalTypedefNameCandidates);
4631 "There are local ones at end of translation unit!");
4648 for (
const auto &I : SemaRef.KnownNamespaces) {
4658 for (
const auto &I : Undefined) {
4668 for (
const auto &DeleteExprsInfo :
4670 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze);
4671 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());
4672 for (
const auto &DeleteLoc : DeleteExprsInfo.second) {
4674 DeleteExprsToAnalyze.push_back(DeleteLoc.second);
4680 WriteControlBlock(PP, Context, isysroot, OutputFile);
4683 Stream.FlushToWord();
4684 ASTBlockRange.first = Stream.GetCurrentBitNo();
4686 ASTBlockStartOffset = Stream.GetCurrentBitNo();
4701 NewGlobalKindDeclPairs.push_back(D->
getKind());
4702 NewGlobalKindDeclPairs.push_back(
GetDeclRef(D));
4706 auto Abv = std::make_shared<BitCodeAbbrev>();
4708 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4709 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
4712 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
4713 bytes(NewGlobalKindDeclPairs));
4717 Abv = std::make_shared<BitCodeAbbrev>();
4719 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4720 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4721 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv));
4722 WriteDeclContextVisibleUpdate(TU);
4725 if (Context.ExternCContext)
4726 WriteDeclContextVisibleUpdate(Context.ExternCContext);
4740 for (
const auto &Number : Context.MangleNumbers)
4741 if (!Number.first->isFromASTFile())
4744 for (
const auto &Number : Context.StaticLocalNumbers)
4745 if (!Number.first->isFromASTFile())
4752 for (
const auto *I : DeclsToEmitEvenIfUnreferenced) {
4784 for (
auto &SelectorAndID : SelectorIDs)
4785 AllSelectors.push_back(SelectorAndID.first);
4786 for (
auto &
Selector : AllSelectors)
4795 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
4796 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
4797 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
4820 auto Abbrev = std::make_shared<BitCodeAbbrev>();
4822 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4823 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
4826 llvm::raw_svector_ostream Out(Buffer);
4828 using namespace llvm::support;
4830 endian::Writer
LE(Out, little);
4831 LE.write<uint8_t>(
static_cast<uint8_t
>(M.
Kind));
4833 LE.write<uint16_t>(Name.size());
4834 Out.write(Name.data(), Name.size());
4840 auto writeBaseIDOrNone = [&](
auto BaseID,
bool ShouldWrite) {
4843 LE.write<uint32_t>(BaseID);
4845 LE.write<uint32_t>(
None);
4862 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
4863 Buffer.data(), Buffer.size());
4868 for (
auto *D : SemaRef.DeclsToCheckForDeferredDiags)
4869 DeclsToCheckForDeferredDiags.push_back(
GetDeclRef(D));
4876 DeclTypesBlockStartOffset = Stream.GetCurrentBitNo();
4880 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord);
4881 while (!DeclTypesToEmit.empty()) {
4882 DeclOrType DOT = DeclTypesToEmit.front();
4883 DeclTypesToEmit.pop();
4885 WriteType(DOT.getType());
4887 WriteDecl(Context, DOT.getDecl());
4889 }
while (!DeclUpdates.empty());
4892 DoneWritingDeclsAndTypes =
true;
4895 WriteTypeDeclOffsets();
4896 if (!DeclUpdatesOffsetsRecord.empty())
4898 WriteFileDeclIDsMap();
4901 WritePreprocessor(PP, isModule);
4903 WriteSelectors(SemaRef);
4904 WriteReferencedSelectorsPool(SemaRef);
4905 WriteLateParsedTemplates(SemaRef);
4906 WriteIdentifierTable(PP, SemaRef.
IdResolver, isModule);
4908 WriteOpenCLExtensions(SemaRef);
4909 WriteCUDAPragmas(SemaRef);
4913 WriteSubmodules(WritingModule);
4918 if (!EagerlyDeserializedDecls.empty())
4921 if (!ModularCodegenDecls.empty())
4925 if (!TentativeDefinitions.empty())
4929 if (!UnusedFileScopedDecls.empty())
4933 if (!WeakUndeclaredIdentifiers.empty())
4935 WeakUndeclaredIdentifiers);
4938 if (!ExtVectorDecls.empty())
4942 if (!VTableUses.empty())
4946 if (!UnusedLocalTypedefNameCandidates.empty())
4948 UnusedLocalTypedefNameCandidates);
4951 if (!PendingInstantiations.empty())
4955 if (!SemaDeclRefs.empty())
4959 if (!DeclsToCheckForDeferredDiags.empty())
4961 DeclsToCheckForDeferredDiags);
4964 if (!CUDASpecialDeclRefs.empty())
4968 if (!DelegatingCtorDecls.empty())
4972 if (!KnownNamespaces.empty())
4976 if (!UndefinedButUsed.empty())
4979 if (!DeleteExprsToAnalyze.empty())
4983 for (
auto *DC : UpdatedDeclContexts)
4984 WriteDeclContextVisibleUpdate(DC);
4986 if (!WritingModule) {
4995 assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end());
4996 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
4997 I->getImportedModule()));
5000 if (!Imports.empty()) {
5001 auto Cmp = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5004 auto Eq = [](
const ModuleInfo &A,
const ModuleInfo &B) {
5005 return A.ID == B.ID;
5009 llvm::sort(Imports, Cmp);
5010 Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq),
5014 for (
const auto &Import : Imports) {
5015 ImportedModules.push_back(Import.ID);
5026 WriteObjCCategories();
5027 if(!WritingModule) {
5028 WriteOptimizePragmaOptions(SemaRef);
5029 WriteMSStructPragmaOptions(SemaRef);
5030 WriteMSPointersToMembersPragmaOptions(SemaRef);
5032 WritePackPragmaOptions(SemaRef);
5033 WriteFloatControlPragmaOptions(SemaRef);
5036 RecordData::value_type Record[] = {
5037 NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts};
5040 Stream.FlushToWord();
5041 ASTBlockRange.second = Stream.GetCurrentBitNo();
5044 for (
const auto &ExtWriter : ModuleFileExtensionWriters)
5045 WriteModuleFileExtension(SemaRef, *ExtWriter);
5047 return writeUnhashedControlBlock(PP, Context);
5050 void ASTWriter::WriteDeclUpdatesBlocks(
RecordDataImpl &OffsetsRecord) {
5051 if (DeclUpdates.empty())
5054 DeclUpdateMap LocalUpdates;
5055 LocalUpdates.swap(DeclUpdates);
5057 for (
auto &DeclUpdate : LocalUpdates) {
5058 const Decl *D = DeclUpdate.first;
5060 bool HasUpdatedBody =
false;
5063 for (
auto &
Update : DeclUpdate.second) {
5069 HasUpdatedBody =
true;
5071 Record.push_back(
Kind);
5077 assert(
Update.getDecl() &&
"no decl to add?");
5086 Record.AddSourceLocation(
Update.getLoc());
5090 const VarDecl *VD = cast<VarDecl>(D);
5093 Record.AddVarDeclInit(VD);
5098 Record.AddStmt(
const_cast<Expr *
>(
5099 cast<ParmVarDecl>(
Update.getDecl())->getDefaultArg()));
5104 cast<FieldDecl>(
Update.getDecl())->getInClassInitializer());
5108 auto *RD = cast<CXXRecordDecl>(D);
5109 UpdatedDeclContexts.insert(RD->getPrimaryContext());
5110 Record.push_back(RD->isParamDestroyedInCallee());
5111 Record.push_back(RD->getArgPassingRestrictions());
5112 Record.AddCXXDefinitionData(RD);
5113 Record.AddOffset(WriteDeclContextLexicalBlock(
5119 if (
auto *MSInfo = RD->getMemberSpecializationInfo()) {
5120 Record.push_back(MSInfo->getTemplateSpecializationKind());
5121 Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
5123 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
5124 Record.push_back(Spec->getTemplateSpecializationKind());
5125 Record.AddSourceLocation(Spec->getPointOfInstantiation());
5129 auto From = Spec->getInstantiatedFrom();
5130 if (
auto PartialSpec =
5132 Record.push_back(
true);
5133 Record.AddDeclRef(PartialSpec);
5134 Record.AddTemplateArgumentList(
5135 &Spec->getTemplateInstantiationArgs());
5137 Record.push_back(
false);
5140 Record.push_back(RD->getTagKind());
5141 Record.AddSourceLocation(RD->getLocation());
5142 Record.AddSourceLocation(RD->getBeginLoc());
5143 Record.AddSourceRange(RD->getBraceRange());
5148 Record.AddAttributes(D->
getAttrs());
5155 Record.AddDeclRef(
Update.getDecl());
5156 Record.AddStmt(cast<CXXDestructorDecl>(D)->getOperatorDeleteThisArg());
5162 Record.writeExceptionSpecInfo(prototype->getExceptionSpecInfo());
5175 Record.push_back(
Update.getNumber());
5179 Record.AddSourceRange(
5180 D->
getAttr<OMPThreadPrivateDeclAttr>()->getRange());
5184 auto *A = D->
getAttr<OMPAllocateDeclAttr>();
5185 Record.push_back(A->getAllocatorType());
5186 Record.AddStmt(A->getAllocator());
5187 Record.AddStmt(A->getAlignment());
5188 Record.AddSourceRange(A->getRange());
5193 Record.push_back(D->
getAttr<OMPDeclareTargetDeclAttr>()->getMapType());
5194 Record.AddSourceRange(
5195 D->
getAttr<OMPDeclareTargetDeclAttr>()->getRange());
5199 Record.push_back(getSubmoduleID(
Update.getModule()));
5203 Record.AddAttributes(llvm::makeArrayRef(
Update.getAttr()));
5208 if (HasUpdatedBody) {
5209 const auto *Def = cast<FunctionDecl>(D);
5211 Record.push_back(Def->isInlined());
5212 Record.AddSourceLocation(Def->getInnerLocStart());
5213 Record.AddFunctionDefinition(Def);
5224 Record.push_back(Raw);
5239 AddAPInt(
Value.bitcastToAPInt());
5266 MacroInfoToEmitData Info = { Name, MI,
ID };
5267 MacroInfosToEmit.push_back(Info);
5276 assert(MacroIDs.find(MI) != MacroIDs.end() &&
"Macro not emitted!");
5277 return MacroIDs[MI];
5281 return IdentMacroDirectivesOffsetMap.lookup(Name);
5285 Record->push_back(Writer->getSelectorRef(SelRef));
5294 if (SID == 0 && Chain) {
5297 Chain->LoadSelector(Sel);
5298 SID = SelectorIDs[Sel];
5301 SID = NextSelectorID++;
5302 SelectorIDs[Sel] = SID;
5343 bool InfoHasSameExpr
5345 Record->push_back(InfoHasSameExpr);
5346 if (InfoHasSameExpr)
5364 TypeLocWriter TLW(*
this, Seq);
5382 if (DoneWritingDeclsAndTypes) {
5383 assert(0 &&
"New type seen after serializing all the types to emit!");
5390 DeclTypesToEmit.push(T);
5403 TypeIdxMap::const_iterator I = TypeIdxs.find(T);
5404 assert(I != TypeIdxs.end() &&
"Type not emitted!");
5414 assert(WritingAST &&
"Cannot request a declaration ID before AST writing");
5425 assert(!(
reinterpret_cast<uintptr_t>(D) & 0x01) &&
"Invalid decl pointer");
5428 if (DoneWritingDeclsAndTypes) {
5429 assert(0 &&
"New decl seen after serializing all the decls to emit!");
5436 DeclTypesToEmit.push(
const_cast<Decl *
>(D));
5451 assert(DeclIDs.find(D) != DeclIDs.end() &&
"Declaration not emitted!");
5455 void ASTWriter::associateDeclWithFile(
const Decl *D,
DeclID ID) {
5470 if (isa<ParmVarDecl>(D) || isa<TemplateTemplateParmDecl>(D))
5475 assert(
SM.isLocalSourceLocation(FileLoc));
5478 std::tie(FID,
Offset) =
SM.getDecomposedLoc(FileLoc);
5481 assert(
SM.getSLocEntry(FID).isFile());
5483 std::unique_ptr<DeclIDInFileInfo> &Info = FileDeclIDs[FID];
5485 Info = std::make_unique<DeclIDInFileInfo>();
5487 std::pair<unsigned, serialization::DeclID> LocDecl(
Offset,
ID);
5488 LocDeclIDsTy &Decls = Info->DeclIDs;
5489 Decls.push_back(LocDecl);
5494 "expected an anonymous declaration");
5498 auto It = AnonymousDeclarationNumbers.find(D);
5499 if (It == AnonymousDeclarationNumbers.end()) {
5502 AnonymousDeclarationNumbers[ND] = Number;
5505 It = AnonymousDeclarationNumbers.find(D);
5506 assert(It != AnonymousDeclarationNumbers.end() &&
5507 "declaration not found within its lexical context");
5515 switch (Name.getNameKind()) {
5542 AddDeclarationName(NameInfo.
getName());
5562 NestedNames.push_back(NNS);
5566 Record->push_back(NestedNames.size());
5567 while(!NestedNames.empty()) {
5568 NNS = NestedNames.pop_back_val();
5571 Record->push_back(
Kind);
5610 assert(TemplateParams &&
"No TemplateParams!");
5615 Record->push_back(TemplateParams->
size());
5616 for (
const auto &
P : *TemplateParams)
5618 if (
const Expr *RequiresClause = TemplateParams->getRequiresClause()) {
5619 Record->push_back(
true);
5620 AddStmt(
const_cast<Expr*
>(RequiresClause));
5622 Record->push_back(
false);
5629 assert(TemplateArgs &&
"No TemplateArgs!");
5630 Record->push_back(TemplateArgs->
size());
5631 for (
int i = 0, e = TemplateArgs->
size(); i != e; ++i)
5632 AddTemplateArgument(TemplateArgs->
get(i));
5637 assert(ASTTemplArgList &&
"No ASTTemplArgList!");
5643 AddTemplateArgumentLoc(TemplArgs[i]);
5647 Record->push_back(Set.
size());
5649 I = Set.
begin(), E = Set.
end(); I != E; ++I) {
5651 Record->push_back(I.getAccess());