32 #include "llvm/Config/llvm-config.h"
87 cl::desc(
"Number of metadatas above which we emit an index "
88 "to enable lazy-loading"));
91 cl::desc(
"The threshold (unit M) for flushing LLVM bitcode."));
95 cl::desc(
"Write relative block frequency to function summary "));
108 VST_BBENTRY_6_ABBREV,
112 CONSTANTS_INTEGER_ABBREV,
113 CONSTANTS_CE_CAST_Abbrev,
114 CONSTANTS_NULL_Abbrev,
118 FUNCTION_INST_UNOP_ABBREV,
119 FUNCTION_INST_UNOP_FLAGS_ABBREV,
120 FUNCTION_INST_BINOP_ABBREV,
121 FUNCTION_INST_BINOP_FLAGS_ABBREV,
122 FUNCTION_INST_CAST_ABBREV,
123 FUNCTION_INST_RET_VOID_ABBREV,
124 FUNCTION_INST_RET_VAL_ABBREV,
125 FUNCTION_INST_UNREACHABLE_ABBREV,
126 FUNCTION_INST_GEP_ABBREV,
131 class BitcodeWriterBase {
142 : Stream(Stream), StrtabBuilder(StrtabBuilder) {}
146 void writeModuleVersion();
149 void BitcodeWriterBase::writeModuleVersion() {
156 class ModuleBitcodeWriterBase :
public BitcodeWriterBase {
170 std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
173 unsigned GlobalValueId;
177 uint64_t VSTOffsetPlaceholder = 0;
184 bool ShouldPreserveUseListOrder,
186 : BitcodeWriterBase(Stream, StrtabBuilder),
M(
M),
196 for (
const auto &GUIDSummaryLists : *
Index)
198 for (
auto &Summary : GUIDSummaryLists.second.SummaryList)
199 if (
auto FS = dyn_cast<FunctionSummary>(Summary.get()))
204 for (
auto &CallEdge :
FS->calls())
205 if (!CallEdge.first.haveGVs() || !CallEdge.first.getValue())
206 assignValueId(CallEdge.first.getGUID());
210 void writePerModuleGlobalValueSummary();
216 unsigned FSCallsAbbrev,
217 unsigned FSCallsProfileAbbrev,
221 unsigned FSModRefsAbbrev,
222 unsigned FSModVTableRefsAbbrev);
225 GUIDToValueIdMap[ValGUID] = ++GlobalValueId;
229 const auto &VMI = GUIDToValueIdMap.find(ValGUID);
232 assert(VMI != GUIDToValueIdMap.end() &&
233 "GUID does not have assigned value Id");
239 if (!
VI.haveGVs() || !
VI.getValue())
240 return getValueId(
VI.getGUID());
244 std::map<GlobalValue::GUID, unsigned> &valueIds() {
return GUIDToValueIdMap; }
248 class ModuleBitcodeWriter :
public ModuleBitcodeWriterBase {
262 uint64_t BitcodeStartBit;
272 : ModuleBitcodeWriterBase(
M, StrtabBuilder, Stream,
273 ShouldPreserveUseListOrder,
Index),
274 Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash),
275 BitcodeStartBit(Stream.GetCurrentBitNo()) {}
281 uint64_t bitcodeStartBit() {
return BitcodeStartBit; }
285 void writeAttributeGroupTable();
286 void writeAttributeTable();
287 void writeTypeTable();
289 void writeValueSymbolTableForwardDecl();
290 void writeModuleInfo();
295 unsigned createDILocationAbbrev();
298 unsigned createGenericDINodeAbbrev();
365 unsigned createNamedMetadataAbbrev();
367 unsigned createMetadataStringsAbbrev();
372 std::vector<unsigned> *MDAbbrevs =
nullptr,
373 std::vector<uint64_t> *IndexPos =
nullptr);
374 void writeModuleMetadata();
375 void writeFunctionMetadata(
const Function &
F);
376 void writeFunctionMetadataAttachment(
const Function &
F);
377 void writeGlobalVariableMetadataAttachment(
const GlobalVariable &GV);
380 void writeModuleMetadataKinds();
381 void writeOperandBundleTags();
382 void writeSyncScopeNames();
383 void writeConstants(
unsigned FirstVal,
unsigned LastVal,
bool isGlobal);
384 void writeModuleConstants();
385 bool pushValueAndType(
const Value *V,
unsigned InstID,
387 void writeOperandBundles(
const CallBase &CB,
unsigned InstID);
388 void pushValue(
const Value *V,
unsigned InstID,
390 void pushValueSigned(
const Value *V,
unsigned InstID,
392 void writeInstruction(
const Instruction &
I,
unsigned InstID,
395 void writeGlobalValueSymbolTable(
398 void writeUseListBlock(
const Function *
F);
402 void writeBlockInfo();
403 void writeModuleHash(
size_t BlockStartPos);
406 return unsigned(SSID);
409 unsigned getEncodedAlign(
MaybeAlign Alignment) {
return encode(Alignment); }
413 class IndexBitcodeWriter :
public BitcodeWriterBase {
419 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex;
423 std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
426 unsigned GlobalValueId = 0;
434 const std::map<std::string, GVSummaryMapTy>
435 *ModuleToSummariesForIndex =
nullptr)
436 : BitcodeWriterBase(Stream, StrtabBuilder),
Index(
Index),
437 ModuleToSummariesForIndex(ModuleToSummariesForIndex) {
442 forEachSummary([&](GVInfo
I,
bool) {
443 GUIDToValueIdMap[
I.first] = ++GlobalValueId;
448 using GVInfo = std::pair<GlobalValue::GUID, GlobalValueSummary *>;
453 template<
typename Functor>
454 void forEachSummary(Functor Callback) {
455 if (ModuleToSummariesForIndex) {
456 for (
auto &M : *ModuleToSummariesForIndex)
457 for (
auto &Summary :
M.second) {
458 Callback(Summary,
false);
462 if (
auto *AS = dyn_cast<AliasSummary>(Summary.getSecond()))
463 Callback({AS->getAliaseeGUID(), &AS->getAliasee()},
true);
466 for (
auto &Summaries :
Index)
467 for (
auto &Summary : Summaries.second.SummaryList)
468 Callback({Summaries.first, Summary.get()},
false);
476 template <
typename Functor>
void forEachModule(Functor Callback) {
477 if (ModuleToSummariesForIndex) {
478 for (
const auto &M : *ModuleToSummariesForIndex) {
479 const auto &MPI =
Index.modulePaths().find(
M.first);
480 if (MPI ==
Index.modulePaths().end()) {
484 assert(ModuleToSummariesForIndex->size() == 1);
490 for (
const auto &MPSE :
Index.modulePaths())
499 void writeModStrings();
500 void writeCombinedGlobalValueSummary();
503 auto VMI = GUIDToValueIdMap.find(ValGUID);
504 if (VMI == GUIDToValueIdMap.end())
509 std::map<GlobalValue::GUID, unsigned> &valueIds() {
return GUIDToValueIdMap; }
545 case Instruction::Sub:
547 case Instruction::Mul:
550 case Instruction::FDiv:
553 case Instruction::FRem:
601 for (
unsigned i = 0,
e = Str.
size();
i !=
e; ++
i) {
604 Vals.push_back(Str[
i]);
613 case Attribute::Alignment:
615 case Attribute::AllocSize:
617 case Attribute::AlwaysInline:
619 case Attribute::ArgMemOnly:
621 case Attribute::Builtin:
623 case Attribute::ByVal:
627 case Attribute::InAlloca:
633 case Attribute::InaccessibleMemOnly:
635 case Attribute::InaccessibleMemOrArgMemOnly:
637 case Attribute::InlineHint:
639 case Attribute::InReg:
643 case Attribute::MinSize:
645 case Attribute::Naked:
647 case Attribute::Nest:
649 case Attribute::NoAlias:
651 case Attribute::NoBuiltin:
653 case Attribute::NoCallback:
655 case Attribute::NoCapture:
657 case Attribute::NoDuplicate:
659 case Attribute::NoFree:
661 case Attribute::NoImplicitFloat:
663 case Attribute::NoInline:
665 case Attribute::NoRecurse:
667 case Attribute::NoMerge:
669 case Attribute::NonLazyBind:
671 case Attribute::NonNull:
673 case Attribute::Dereferenceable:
675 case Attribute::DereferenceableOrNull:
677 case Attribute::NoRedZone:
679 case Attribute::NoReturn:
681 case Attribute::NoSync:
683 case Attribute::NoCfCheck:
685 case Attribute::NoProfile:
687 case Attribute::NoUnwind:
689 case Attribute::NullPointerIsValid:
691 case Attribute::OptForFuzzing:
693 case Attribute::OptimizeForSize:
695 case Attribute::OptimizeNone:
697 case Attribute::ReadNone:
701 case Attribute::Returned:
703 case Attribute::ReturnsTwice:
705 case Attribute::SExt:
707 case Attribute::Speculatable:
709 case Attribute::StackAlignment:
711 case Attribute::StackProtect:
713 case Attribute::StackProtectReq:
715 case Attribute::StackProtectStrong:
717 case Attribute::SafeStack:
719 case Attribute::ShadowCallStack:
721 case Attribute::StrictFP:
723 case Attribute::StructRet:
725 case Attribute::SanitizeAddress:
727 case Attribute::SanitizeHWAddress:
729 case Attribute::SanitizeThread:
731 case Attribute::SanitizeMemory:
733 case Attribute::SpeculativeLoadHardening:
735 case Attribute::SwiftError:
737 case Attribute::SwiftSelf:
739 case Attribute::UWTable:
741 case Attribute::VScaleRange:
743 case Attribute::WillReturn:
745 case Attribute::WriteOnly:
747 case Attribute::ZExt:
749 case Attribute::ImmArg:
751 case Attribute::SanitizeMemTag:
753 case Attribute::Preallocated:
755 case Attribute::NoUndef:
757 case Attribute::ByRef:
759 case Attribute::MustProgress:
773 void ModuleBitcodeWriter::writeAttributeGroupTable() {
774 const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
776 if (AttrGrps.empty())
return;
782 unsigned AttrListIndex = Pair.first;
785 Record.push_back(AttrListIndex);
788 if (Attr.isEnumAttribute()) {
791 }
else if (Attr.isIntAttribute()) {
794 Record.push_back(Attr.getValueAsInt());
795 }
else if (Attr.isStringAttribute()) {
807 assert(Attr.isTypeAttribute());
808 Type *Ty = Attr.getValueAsType();
809 Record.push_back(Ty ? 6 : 5);
823 void ModuleBitcodeWriter::writeAttributeTable() {
832 for (
unsigned i =
AL.index_begin(),
e =
AL.index_end();
i !=
e; ++
i) {
846 void ModuleBitcodeWriter::writeTypeTable() {
855 auto Abbv = std::make_shared<BitCodeAbbrev>();
862 Abbv = std::make_shared<BitCodeAbbrev>();
870 Abbv = std::make_shared<BitCodeAbbrev>();
878 Abbv = std::make_shared<BitCodeAbbrev>();
885 Abbv = std::make_shared<BitCodeAbbrev>();
893 Abbv = std::make_shared<BitCodeAbbrev>();
900 TypeVals.push_back(TypeList.size());
905 for (
unsigned i = 0,
e = TypeList.size();
i !=
e; ++
i) {
910 switch (
T->getTypeID()) {
927 TypeVals.push_back(cast<IntegerType>(T)->
getBitWidth());
947 AbbrevToUse = FunctionAbbrev;
953 TypeVals.push_back(
ST->isPacked());
956 E =
ST->element_end();
I !=
E; ++
I)
959 if (
ST->isLiteral()) {
961 AbbrevToUse = StructAnonAbbrev;
963 if (
ST->isOpaque()) {
967 AbbrevToUse = StructNamedAbbrev;
971 if (!
ST->getName().empty())
983 AbbrevToUse = ArrayAbbrev;
994 if (isa<ScalableVectorType>(VT))
995 TypeVals.push_back(
true);
1001 Stream.
EmitRecord(Code, TypeVals, AbbrevToUse);
1041 uint64_t RawFlags = 0;
1054 uint64_t RawFlags = 0;
1057 RawFlags |= (Flags.
Live << 1);
1064 RawFlags = (RawFlags << 4) | Flags.
Linkage;
1107 switch (
C.getSelectionKind()) {
1131 size_t ModuleBitcodeWriter::addToStrtab(
StringRef Str) {
1134 return StrtabBuilder.
add(Str);
1137 void ModuleBitcodeWriter::writeComdats() {
1141 Vals.push_back(addToStrtab(
C->getName()));
1142 Vals.push_back(
C->getName().size());
1152 void ModuleBitcodeWriter::writeValueSymbolTableForwardDecl() {
1157 auto Abbv = std::make_shared<BitCodeAbbrev>();
1179 bool isChar6 =
true;
1180 for (
char C : Str) {
1183 if ((
unsigned char)
C & 128)
1195 void ModuleBitcodeWriter::writeModuleInfo() {
1197 if (!
M.getTargetTriple().empty())
1200 const std::string &
DL =
M.getDataLayoutStr();
1203 if (!
M.getModuleInlineAsm().empty())
1209 std::map<std::string, unsigned> SectionMap;
1210 std::map<std::string, unsigned> GCMap;
1212 unsigned MaxGlobalType = 0;
1213 const auto UpdateMaxAlignment = [&MaxAlignment](
const MaybeAlign A) {
1215 MaxAlignment = !MaxAlignment ? *
A :
std::max(*MaxAlignment, *A);
1218 UpdateMaxAlignment(GV.getAlign());
1220 if (GV.hasSection()) {
1222 unsigned &Entry = SectionMap[std::string(GV.getSection())];
1226 Entry = SectionMap.size();
1231 UpdateMaxAlignment(
F.getAlign());
1232 if (
F.hasSection()) {
1234 unsigned &Entry = SectionMap[std::string(
F.getSection())];
1238 Entry = SectionMap.size();
1243 unsigned &Entry = GCMap[
F.getGC()];
1247 Entry = GCMap.size();
1253 unsigned SimpleGVarAbbrev = 0;
1254 if (!
M.global_empty()) {
1256 auto Abbv = std::make_shared<BitCodeAbbrev>();
1270 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1274 if (SectionMap.empty())
1294 auto Abbv = std::make_shared<BitCodeAbbrev>();
1297 Abbv->Add(AbbrevOpToUse);
1300 for (
const auto P :
M.getSourceFileName())
1301 Vals.push_back((
unsigned char)
P);
1310 unsigned AbbrevToUse = 0;
1316 Vals.push_back(addToStrtab(GV.getName()));
1317 Vals.push_back(GV.getName().size());
1318 Vals.push_back(VE.
getTypeID(GV.getValueType()));
1319 Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
1320 Vals.push_back(GV.isDeclaration() ? 0 :
1323 Vals.push_back(getEncodedAlign(GV.getAlign()));
1324 Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1326 if (GV.isThreadLocal() ||
1329 GV.isExternallyInitialized() ||
1332 GV.hasAttributes() ||
1334 GV.hasPartition()) {
1338 Vals.push_back(GV.isExternallyInitialized());
1340 Vals.push_back(GV.hasComdat() ? VE.
getComdatID(GV.getComdat()) : 0);
1345 Vals.push_back(GV.isDSOLocal());
1346 Vals.push_back(addToStrtab(GV.getPartition()));
1347 Vals.push_back(GV.getPartition().size());
1349 AbbrevToUse = SimpleGVarAbbrev;
1362 Vals.push_back(addToStrtab(
F.getName()));
1363 Vals.push_back(
F.getName().size());
1364 Vals.push_back(VE.
getTypeID(
F.getFunctionType()));
1365 Vals.push_back(
F.getCallingConv());
1366 Vals.push_back(
F.isDeclaration());
1369 Vals.push_back(getEncodedAlign(
F.getAlign()));
1370 Vals.push_back(
F.hasSection() ? SectionMap[std::string(
F.getSection())]
1373 Vals.push_back(
F.hasGC() ? GCMap[
F.getGC()] : 0);
1375 Vals.push_back(
F.hasPrologueData() ? (VE.
getValueID(
F.getPrologueData()) + 1)
1378 Vals.push_back(
F.hasComdat() ? VE.
getComdatID(
F.getComdat()) : 0);
1379 Vals.push_back(
F.hasPrefixData() ? (VE.
getValueID(
F.getPrefixData()) + 1)
1382 F.hasPersonalityFn() ? (VE.
getValueID(
F.getPersonalityFn()) + 1) : 0);
1384 Vals.push_back(
F.isDSOLocal());
1385 Vals.push_back(
F.getAddressSpace());
1386 Vals.push_back(addToStrtab(
F.getPartition()));
1387 Vals.push_back(
F.getPartition().size());
1389 unsigned AbbrevToUse = 0;
1399 Vals.push_back(addToStrtab(
A.getName()));
1400 Vals.push_back(
A.getName().size());
1401 Vals.push_back(VE.
getTypeID(
A.getValueType()));
1402 Vals.push_back(
A.getType()->getAddressSpace());
1409 Vals.push_back(
A.isDSOLocal());
1410 Vals.push_back(addToStrtab(
A.getPartition()));
1411 Vals.push_back(
A.getPartition().size());
1413 unsigned AbbrevToUse = 0;
1422 Vals.push_back(addToStrtab(
I.getName()));
1423 Vals.push_back(
I.getName().size());
1424 Vals.push_back(VE.
getTypeID(
I.getValueType()));
1425 Vals.push_back(
I.getType()->getAddressSpace());
1429 Vals.push_back(
I.isDSOLocal());
1430 Vals.push_back(addToStrtab(
I.getPartition()));
1431 Vals.push_back(
I.getPartition().size());
1436 writeValueSymbolTableForwardDecl();
1442 if (
const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
1443 if (OBO->hasNoSignedWrap())
1445 if (OBO->hasNoUnsignedWrap())
1447 }
else if (
const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
1450 }
else if (
const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
1451 if (FPMO->hasAllowReassoc())
1453 if (FPMO->hasNoNaNs())
1455 if (FPMO->hasNoInfs())
1457 if (FPMO->hasNoSignedZeros())
1459 if (FPMO->hasAllowReciprocal())
1461 if (FPMO->hasAllowContract())
1463 if (FPMO->hasApproxFunc())
1470 void ModuleBitcodeWriter::writeValueAsMetadata(
1483 for (
unsigned i = 0,
e =
N->getNumOperands();
i !=
e; ++
i) {
1485 assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1486 "Unexpected function-local metadata");
1495 unsigned ModuleBitcodeWriter::createDILocationAbbrev() {
1498 auto Abbv = std::make_shared<BitCodeAbbrev>();
1513 Abbrev = createDILocationAbbrev();
1515 Record.push_back(
N->isDistinct());
1516 Record.push_back(
N->getLine());
1517 Record.push_back(
N->getColumn());
1520 Record.push_back(
N->isImplicitCode());
1526 unsigned ModuleBitcodeWriter::createGenericDINodeAbbrev() {
1529 auto Abbv = std::make_shared<BitCodeAbbrev>();
1544 Abbrev = createGenericDINodeAbbrev();
1546 Record.push_back(
N->isDistinct());
1547 Record.push_back(
N->getTag());
1550 for (
auto &
I :
N->operands())
1560 const uint64_t
Version = 2 << 1;
1574 Record.push_back((uint64_t)
N->isDistinct());
1585 if ((int64_t)V >= 0)
1586 Vals.push_back(V << 1);
1588 Vals.push_back((-V << 1) | 1);
1596 unsigned NumWords = A.getActiveWords();
1597 const uint64_t *RawData = A.getRawData();
1598 for (
unsigned i = 0;
i < NumWords;
i++)
1605 const uint64_t IsBigInt = 1 << 2;
1606 Record.push_back(IsBigInt | (
N->isUnsigned() << 1) |
N->isDistinct());
1607 Record.push_back(
N->getValue().getBitWidth());
1618 Record.push_back(
N->isDistinct());
1619 Record.push_back(
N->getTag());
1621 Record.push_back(
N->getSizeInBits());
1622 Record.push_back(
N->getAlignInBits());
1623 Record.push_back(
N->getEncoding());
1624 Record.push_back(
N->getFlags());
1633 Record.push_back(
N->isDistinct());
1634 Record.push_back(
N->getTag());
1638 Record.push_back(
N->getSizeInBits());
1639 Record.push_back(
N->getAlignInBits());
1640 Record.push_back(
N->getEncoding());
1649 Record.push_back(
N->isDistinct());
1650 Record.push_back(
N->getTag());
1653 Record.push_back(
N->getLine());
1656 Record.push_back(
N->getSizeInBits());
1657 Record.push_back(
N->getAlignInBits());
1658 Record.push_back(
N->getOffsetInBits());
1659 Record.push_back(
N->getFlags());
1664 if (
const auto &DWARFAddressSpace =
N->getDWARFAddressSpace())
1665 Record.push_back(*DWARFAddressSpace + 1);
1676 const unsigned IsNotUsedInOldTypeRef = 0x2;
1677 Record.push_back(IsNotUsedInOldTypeRef | (
unsigned)
N->isDistinct());
1678 Record.push_back(
N->getTag());
1681 Record.push_back(
N->getLine());
1684 Record.push_back(
N->getSizeInBits());
1685 Record.push_back(
N->getAlignInBits());
1686 Record.push_back(
N->getOffsetInBits());
1687 Record.push_back(
N->getFlags());
1689 Record.push_back(
N->getRuntimeLang());
1706 const unsigned HasNoOldTypeRefs = 0x2;
1707 Record.push_back(HasNoOldTypeRefs | (
unsigned)
N->isDistinct());
1708 Record.push_back(
N->getFlags());
1719 Record.push_back(
N->isDistinct());
1722 if (
N->getRawChecksum()) {
1723 Record.push_back(
N->getRawChecksum()->Kind);
1731 auto Source =
N->getRawSource();
1742 assert(
N->isDistinct() &&
"Expected distinct compile units");
1744 Record.push_back(
N->getSourceLanguage());
1747 Record.push_back(
N->isOptimized());
1749 Record.push_back(
N->getRuntimeVersion());
1751 Record.push_back(
N->getEmissionKind());
1757 Record.push_back(
N->getDWOId());
1759 Record.push_back(
N->getSplitDebugInlining());
1760 Record.push_back(
N->getDebugInfoForProfiling());
1761 Record.push_back((
unsigned)
N->getNameTableKind());
1762 Record.push_back(
N->getRangesBaseAddress());
1773 const uint64_t HasUnitFlag = 1 << 1;
1774 const uint64_t HasSPFlagsFlag = 1 << 2;
1775 Record.push_back(uint64_t(
N->isDistinct()) | HasUnitFlag | HasSPFlagsFlag);
1780 Record.push_back(
N->getLine());
1782 Record.push_back(
N->getScopeLine());
1784 Record.push_back(
N->getSPFlags());
1785 Record.push_back(
N->getVirtualIndex());
1786 Record.push_back(
N->getFlags());
1791 Record.push_back(
N->getThisAdjustment());
1801 Record.push_back(
N->isDistinct());
1804 Record.push_back(
N->getLine());
1805 Record.push_back(
N->getColumn());
1814 Record.push_back(
N->isDistinct());
1817 Record.push_back(
N->getDiscriminator());
1826 Record.push_back(
N->isDistinct());
1831 Record.push_back(
N->getLineNo());
1840 Record.push_back(
N->isDistinct() |
N->getExportSymbols() << 1);
1851 Record.push_back(
N->isDistinct());
1852 Record.push_back(
N->getMacinfoType());
1853 Record.push_back(
N->getLine());
1864 Record.push_back(
N->isDistinct());
1865 Record.push_back(
N->getMacinfoType());
1866 Record.push_back(
N->getLine());
1877 Record.reserve(
N->getArgs().size());
1888 Record.push_back(
N->isDistinct());
1889 for (
auto &
I :
N->operands())
1891 Record.push_back(
N->getLineNo());
1892 Record.push_back(
N->getIsDecl());
1901 Record.push_back(
N->isDistinct());
1904 Record.push_back(
N->isDefault());
1913 Record.push_back(
N->isDistinct());
1914 Record.push_back(
N->getTag());
1917 Record.push_back(
N->isDefault());
1927 const uint64_t
Version = 2 << 1;
1933 Record.push_back(
N->getLine());
1935 Record.push_back(
N->isLocalToUnit());
1936 Record.push_back(
N->isDefinition());
1939 Record.push_back(
N->getAlignInBits());
1961 const uint64_t HasAlignmentFlag = 1 << 1;
1962 Record.push_back((uint64_t)
N->isDistinct() | HasAlignmentFlag);
1966 Record.push_back(
N->getLine());
1968 Record.push_back(
N->getArg());
1969 Record.push_back(
N->getFlags());
1970 Record.push_back(
N->getAlignInBits());
1979 Record.push_back((uint64_t)
N->isDistinct());
1983 Record.push_back(
N->getLine());
1992 Record.reserve(
N->getElements().size() + 1);
1993 const uint64_t
Version = 3 << 1;
1995 Record.append(
N->elements_begin(),
N->elements_end());
2004 Record.push_back(
N->isDistinct());
2015 Record.push_back(
N->isDistinct());
2018 Record.push_back(
N->getLine());
2021 Record.push_back(
N->getAttributes());
2031 Record.push_back(
N->isDistinct());
2032 Record.push_back(
N->getTag());
2035 Record.push_back(
N->getLine());
2043 unsigned ModuleBitcodeWriter::createNamedMetadataAbbrev() {
2044 auto Abbv = std::make_shared<BitCodeAbbrev>();
2051 void ModuleBitcodeWriter::writeNamedMetadata(
2053 if (
M.named_metadata_empty())
2056 unsigned Abbrev = createNamedMetadataAbbrev();
2065 for (
const MDNode *
N : NMD.operands())
2072 unsigned ModuleBitcodeWriter::createMetadataStringsAbbrev() {
2073 auto Abbv = std::make_shared<BitCodeAbbrev>();
2085 void ModuleBitcodeWriter::writeMetadataStrings(
2087 if (Strings.empty())
2092 Record.push_back(Strings.size());
2099 W.EmitVBR(cast<MDString>(MD)->getLength(), 6);
2104 Record.push_back(Blob.size());
2108 Blob.
append(cast<MDString>(MD)->getString());
2117 #define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
2118 #include "llvm/IR/Metadata.def"
2122 void ModuleBitcodeWriter::writeMetadataRecords(
2124 std::vector<unsigned> *MDAbbrevs, std::vector<uint64_t> *IndexPos) {
2129 #define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
2130 #include "llvm/IR/Metadata.def"
2135 if (
const MDNode *
N = dyn_cast<MDNode>(MD)) {
2136 assert(
N->isResolved() &&
"Expected forward references to be resolved");
2138 switch (
N->getMetadataID()) {
2141 #define HANDLE_MDNODE_LEAF(CLASS) \
2142 case Metadata::CLASS##Kind: \
2144 write##CLASS(cast<CLASS>(N), Record, \
2145 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
2147 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
2149 #include "llvm/IR/Metadata.def"
2152 writeValueAsMetadata(cast<ValueAsMetadata>(MD),
Record);
2156 void ModuleBitcodeWriter::writeModuleMetadata() {
2157 if (!VE.
hasMDs() &&
M.named_metadata_empty())
2165 std::vector<unsigned> MDAbbrevs;
2168 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
2169 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
2170 createGenericDINodeAbbrev();
2172 auto Abbv = std::make_shared<BitCodeAbbrev>();
2178 Abbv = std::make_shared<BitCodeAbbrev>();
2194 uint64_t Vals[] = {0, 0};
2204 std::vector<uint64_t> IndexPos;
2219 uint64_t PreviousValue = IndexOffsetRecordBitPos;
2220 for (
auto &Elt : IndexPos) {
2221 auto EltDelta = Elt - PreviousValue;
2222 PreviousValue = Elt;
2231 writeNamedMetadata(
Record);
2233 auto AddDeclAttachedMetadata = [&](
const GlobalObject &GO) {
2236 pushGlobalMetadataAttachment(
Record, GO);
2240 if (
F.isDeclaration() &&
F.hasMetadata())
2241 AddDeclAttachedMetadata(
F);
2245 if (GV.hasMetadata())
2246 AddDeclAttachedMetadata(GV);
2251 void ModuleBitcodeWriter::writeFunctionMetadata(
const Function &
F) {
2262 void ModuleBitcodeWriter::pushGlobalMetadataAttachment(
2267 for (
const auto &
I : MDs) {
2273 void ModuleBitcodeWriter::writeFunctionMetadataAttachment(
const Function &
F) {
2278 if (
F.hasMetadata()) {
2279 pushGlobalMetadataAttachment(
Record,
F);
2290 I.getAllMetadataOtherThanDebugLoc(MDs);
2293 if (MDs.empty())
continue;
2297 for (
unsigned i = 0,
e = MDs.size();
i !=
e; ++
i) {
2298 Record.push_back(MDs[
i].first);
2308 void ModuleBitcodeWriter::writeModuleMetadataKinds() {
2314 M.getMDKindNames(Names);
2316 if (Names.empty())
return;
2320 for (
unsigned MDKindID = 0,
e = Names.size(); MDKindID !=
e; ++MDKindID) {
2321 Record.push_back(MDKindID);
2332 void ModuleBitcodeWriter::writeOperandBundleTags() {
2340 M.getOperandBundleTags(Tags);
2349 for (
auto Tag : Tags) {
2359 void ModuleBitcodeWriter::writeSyncScopeNames() {
2361 M.getContext().getSyncScopeNames(SSNs);
2368 for (
auto SSN : SSNs) {
2369 Record.append(SSN.begin(), SSN.end());
2377 void ModuleBitcodeWriter::writeConstants(
unsigned FirstVal,
unsigned LastVal,
2379 if (FirstVal == LastVal)
return;
2383 unsigned AggregateAbbrev = 0;
2384 unsigned String8Abbrev = 0;
2385 unsigned CString7Abbrev = 0;
2386 unsigned CString6Abbrev = 0;
2390 auto Abbv = std::make_shared<BitCodeAbbrev>();
2397 Abbv = std::make_shared<BitCodeAbbrev>();
2403 Abbv = std::make_shared<BitCodeAbbrev>();
2409 Abbv = std::make_shared<BitCodeAbbrev>();
2419 Type *LastTy =
nullptr;
2420 for (
unsigned i = FirstVal;
i != LastVal; ++
i) {
2421 const Value *V = Vals[
i].first;
2427 CONSTANTS_SETTYPE_ABBREV);
2431 if (
const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2432 Record.push_back(
unsigned(IA->hasSideEffects()) |
2433 unsigned(IA->isAlignStack()) << 1 |
2434 unsigned(IA->getDialect()&1) << 2);
2437 const std::string &AsmStr = IA->getAsmString();
2438 Record.push_back(AsmStr.size());
2439 Record.append(AsmStr.begin(), AsmStr.end());
2442 const std::string &ConstraintStr = IA->getConstraintString();
2443 Record.push_back(ConstraintStr.size());
2444 Record.append(ConstraintStr.begin(), ConstraintStr.end());
2450 unsigned Code = -1U;
2451 unsigned AbbrevToUse = 0;
2452 if (
C->isNullValue()) {
2454 }
else if (isa<PoisonValue>(
C)) {
2456 }
else if (isa<UndefValue>(
C)) {
2458 }
else if (
const ConstantInt *IV = dyn_cast<ConstantInt>(
C)) {
2459 if (IV->getBitWidth() <= 64) {
2460 uint64_t V = IV->getSExtValue();
2463 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2468 }
else if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(
C)) {
2470 Type *Ty = CFP->getType();
2473 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2477 APInt api = CFP->getValueAPF().bitcastToAPInt();
2479 Record.push_back((
p[1] << 48) | (
p[0] >> 16));
2480 Record.push_back(
p[0] & 0xffffLL);
2482 APInt api = CFP->getValueAPF().bitcastToAPInt();
2487 assert(0 &&
"Unknown FP type!");
2489 }
else if (isa<ConstantDataSequential>(
C) &&
2490 cast<ConstantDataSequential>(
C)->isString()) {
2500 AbbrevToUse = String8Abbrev;
2504 for (
unsigned i = 0;
i != NumElts; ++
i) {
2507 isCStr7 &= (V & 128) == 0;
2513 AbbrevToUse = CString6Abbrev;
2515 AbbrevToUse = CString7Abbrev;
2517 dyn_cast<ConstantDataSequential>(
C)) {
2519 Type *EltTy = CDS->getElementType();
2520 if (isa<IntegerType>(EltTy)) {
2521 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i)
2522 Record.push_back(CDS->getElementAsInteger(
i));
2524 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i)
2526 CDS->getElementAsAPFloat(
i).bitcastToAPInt().getLimitedValue());
2528 }
else if (isa<ConstantAggregate>(
C)) {
2530 for (
const Value *
Op :
C->operands())
2532 AbbrevToUse = AggregateAbbrev;
2533 }
else if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(
C)) {
2534 switch (
CE->getOpcode()) {
2541 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2543 assert(
CE->getNumOperands() == 2 &&
"Unknown constant expr!");
2553 case Instruction::FNeg: {
2554 assert(
CE->getNumOperands() == 1 &&
"Unknown constant expr!");
2563 case Instruction::GetElementPtr: {
2565 const auto *GO = cast<GEPOperator>(
C);
2569 Record.push_back((*Idx << 1) | GO->isInBounds());
2570 }
else if (GO->isInBounds())
2572 for (
unsigned i = 0,
e =
CE->getNumOperands();
i !=
e; ++
i) {
2584 case Instruction::ExtractElement:
2591 case Instruction::InsertElement:
2598 case Instruction::ShuffleVector:
2603 if (
C->getType() ==
C->getOperand(0)->getType()) {
2613 case Instruction::ICmp:
2614 case Instruction::FCmp:
2619 Record.push_back(
CE->getPredicate());
2622 }
else if (
const BlockAddress *BA = dyn_cast<BlockAddress>(
C)) {
2627 }
else if (
const auto *Equiv = dyn_cast<DSOLocalEquivalent>(
C)) {
2644 void ModuleBitcodeWriter::writeModuleConstants() {
2649 for (
unsigned i = 0,
e = Vals.size();
i !=
e; ++
i) {
2650 if (!isa<GlobalValue>(Vals[
i].first)) {
2651 writeConstants(
i, Vals.size(),
true);
2665 bool ModuleBitcodeWriter::pushValueAndType(
const Value *V,
unsigned InstID,
2669 Vals.push_back(InstID -
ValID);
2670 if (
ValID >= InstID) {
2677 void ModuleBitcodeWriter::writeOperandBundles(
const CallBase &CS,
2684 Record.push_back(
C.getOperandBundleTagID(Bundle.getTagName()));
2686 for (
auto &Input : Bundle.Inputs)
2687 pushValueAndType(Input, InstID,
Record);
2696 void ModuleBitcodeWriter::pushValue(
const Value *V,
unsigned InstID,
2699 Vals.push_back(InstID -
ValID);
2702 void ModuleBitcodeWriter::pushValueSigned(
const Value *V,
unsigned InstID,
2705 int64_t diff = ((int32_t)InstID - (int32_t)
ValID);
2710 void ModuleBitcodeWriter::writeInstruction(
const Instruction &
I,
2714 unsigned AbbrevToUse = 0;
2716 switch (
I.getOpcode()) {
2720 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2721 AbbrevToUse = FUNCTION_INST_CAST_ABBREV;
2725 assert(isa<BinaryOperator>(
I) &&
"Unknown instruction!");
2727 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2728 AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;
2729 pushValue(
I.getOperand(1), InstID, Vals);
2733 if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)
2734 AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;
2735 Vals.push_back(Flags);
2739 case Instruction::FNeg: {
2741 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2742 AbbrevToUse = FUNCTION_INST_UNOP_ABBREV;
2746 if (AbbrevToUse == FUNCTION_INST_UNOP_ABBREV)
2747 AbbrevToUse = FUNCTION_INST_UNOP_FLAGS_ABBREV;
2748 Vals.push_back(Flags);
2752 case Instruction::GetElementPtr: {
2754 AbbrevToUse = FUNCTION_INST_GEP_ABBREV;
2755 auto &GEPInst = cast<GetElementPtrInst>(
I);
2756 Vals.push_back(GEPInst.isInBounds());
2757 Vals.push_back(VE.
getTypeID(GEPInst.getSourceElementType()));
2758 for (
unsigned i = 0,
e =
I.getNumOperands();
i !=
e; ++
i)
2759 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2762 case Instruction::ExtractValue: {
2764 pushValueAndType(
I.getOperand(0), InstID, Vals);
2769 case Instruction::InsertValue: {
2771 pushValueAndType(
I.getOperand(0), InstID, Vals);
2772 pushValueAndType(
I.getOperand(1), InstID, Vals);
2779 pushValueAndType(
I.getOperand(1), InstID, Vals);
2780 pushValue(
I.getOperand(2), InstID, Vals);
2781 pushValueAndType(
I.getOperand(0), InstID, Vals);
2784 Vals.push_back(Flags);
2787 case Instruction::ExtractElement:
2789 pushValueAndType(
I.getOperand(0), InstID, Vals);
2790 pushValueAndType(
I.getOperand(1), InstID, Vals);
2792 case Instruction::InsertElement:
2794 pushValueAndType(
I.getOperand(0), InstID, Vals);
2795 pushValue(
I.getOperand(1), InstID, Vals);
2796 pushValueAndType(
I.getOperand(2), InstID, Vals);
2798 case Instruction::ShuffleVector:
2800 pushValueAndType(
I.getOperand(0), InstID, Vals);
2801 pushValue(
I.getOperand(1), InstID, Vals);
2802 pushValue(cast<ShuffleVectorInst>(
I).getShuffleMaskForBitcode(), InstID,
2805 case Instruction::ICmp:
2806 case Instruction::FCmp: {
2809 pushValueAndType(
I.getOperand(0), InstID, Vals);
2810 pushValue(
I.getOperand(1), InstID, Vals);
2814 Vals.push_back(Flags);
2821 unsigned NumOperands =
I.getNumOperands();
2822 if (NumOperands == 0)
2823 AbbrevToUse = FUNCTION_INST_RET_VOID_ABBREV;
2824 else if (NumOperands == 1) {
2825 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2826 AbbrevToUse = FUNCTION_INST_RET_VAL_ABBREV;
2828 for (
unsigned i = 0,
e = NumOperands;
i !=
e; ++
i)
2829 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2833 case Instruction::Br:
2844 case Instruction::Switch:
2848 Vals.push_back(VE.
getTypeID(
SI.getCondition()->getType()));
2849 pushValue(
SI.getCondition(), InstID, Vals);
2851 for (
auto Case :
SI.cases()) {
2852 Vals.push_back(VE.
getValueID(Case.getCaseValue()));
2853 Vals.push_back(VE.
getValueID(Case.getCaseSuccessor()));
2857 case Instruction::IndirectBr:
2859 Vals.push_back(VE.
getTypeID(
I.getOperand(0)->getType()));
2861 pushValue(
I.getOperand(0), InstID, Vals);
2862 for (
unsigned i = 1,
e =
I.getNumOperands();
i !=
e; ++
i)
2866 case Instruction::Invoke: {
2872 writeOperandBundles(*II, InstID);
2881 pushValueAndType(Callee, InstID, Vals);
2885 pushValue(
I.getOperand(
i), InstID, Vals);
2891 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2895 case Instruction::Resume:
2897 pushValueAndType(
I.getOperand(0), InstID, Vals);
2899 case Instruction::CleanupRet: {
2901 const auto &CRI = cast<CleanupReturnInst>(
I);
2902 pushValue(CRI.getCleanupPad(), InstID, Vals);
2903 if (CRI.hasUnwindDest())
2904 Vals.push_back(VE.
getValueID(CRI.getUnwindDest()));
2907 case Instruction::CatchRet: {
2909 const auto &CRI = cast<CatchReturnInst>(
I);
2910 pushValue(CRI.getCatchPad(), InstID, Vals);
2911 Vals.push_back(VE.
getValueID(CRI.getSuccessor()));
2914 case Instruction::CleanupPad:
2915 case Instruction::CatchPad: {
2916 const auto &FuncletPad = cast<FuncletPadInst>(
I);
2919 pushValue(FuncletPad.getParentPad(), InstID, Vals);
2921 unsigned NumArgOperands = FuncletPad.getNumArgOperands();
2922 Vals.push_back(NumArgOperands);
2923 for (
unsigned Op = 0;
Op != NumArgOperands; ++
Op)
2924 pushValueAndType(FuncletPad.getArgOperand(
Op), InstID, Vals);
2927 case Instruction::CatchSwitch: {
2929 const auto &CatchSwitch = cast<CatchSwitchInst>(
I);
2931 pushValue(CatchSwitch.getParentPad(), InstID, Vals);
2933 unsigned NumHandlers = CatchSwitch.getNumHandlers();
2934 Vals.push_back(NumHandlers);
2935 for (
const BasicBlock *CatchPadBB : CatchSwitch.handlers())
2938 if (CatchSwitch.hasUnwindDest())
2939 Vals.push_back(VE.
getValueID(CatchSwitch.getUnwindDest()));
2942 case Instruction::CallBr: {
2948 writeOperandBundles(*CBI, InstID);
2963 pushValueAndType(Callee, InstID, Vals);
2967 pushValue(
I.getOperand(
i), InstID, Vals);
2973 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2977 case Instruction::Unreachable:
2979 AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
2982 case Instruction::PHI: {
2983 const PHINode &PN = cast<PHINode>(
I);
2997 Vals64.push_back(Flags);
3000 Stream.
EmitRecord(Code, Vals64, AbbrevToUse);
3005 case Instruction::LandingPad: {
3016 pushValueAndType(LP.
getClause(
I), InstID, Vals);
3021 case Instruction::Alloca: {
3025 Vals.push_back(VE.
getTypeID(
I.getOperand(0)->getType()));
3029 Bitfield::set<APV::Align>(
Record, getEncodedAlign(AI.
getAlign()));
3031 Bitfield::set<APV::ExplicitType>(
Record,
true);
3040 pushValueAndType(
I.getOperand(0), InstID, Vals);
3043 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
3044 AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
3047 Vals.push_back(getEncodedAlign(cast<LoadInst>(
I).
getAlign()));
3048 Vals.push_back(cast<LoadInst>(
I).isVolatile());
3051 Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(
I).getSyncScopeID()));
3059 pushValueAndType(
I.getOperand(1), InstID, Vals);
3060 pushValueAndType(
I.getOperand(0), InstID, Vals);
3061 Vals.push_back(getEncodedAlign(cast<StoreInst>(
I).
getAlign()));
3062 Vals.push_back(cast<StoreInst>(
I).isVolatile());
3066 getEncodedSyncScopeID(cast<StoreInst>(
I).getSyncScopeID()));
3069 case Instruction::AtomicCmpXchg:
3071 pushValueAndType(
I.getOperand(0), InstID, Vals);
3072 pushValueAndType(
I.getOperand(1), InstID, Vals);
3073 pushValue(
I.getOperand(2), InstID, Vals);
3074 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isVolatile());
3078 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(
I).getSyncScopeID()));
3081 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isWeak());
3082 Vals.push_back(getEncodedAlign(cast<AtomicCmpXchgInst>(
I).
getAlign()));
3084 case Instruction::AtomicRMW:
3086 pushValueAndType(
I.getOperand(0), InstID, Vals);
3087 pushValue(
I.getOperand(1), InstID, Vals);
3090 Vals.push_back(cast<AtomicRMWInst>(
I).isVolatile());
3093 getEncodedSyncScopeID(cast<AtomicRMWInst>(
I).getSyncScopeID()));
3094 Vals.push_back(getEncodedAlign(cast<AtomicRMWInst>(
I).
getAlign()));
3096 case Instruction::Fence:
3099 Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(
I).getSyncScopeID()));
3106 writeOperandBundles(CI, InstID);
3120 Vals.push_back(Flags);
3142 case Instruction::VAArg:
3144 Vals.push_back(VE.
getTypeID(
I.getOperand(0)->getType()));
3145 pushValue(
I.getOperand(0), InstID, Vals);
3148 case Instruction::Freeze:
3150 pushValueAndType(
I.getOperand(0), InstID, Vals);
3160 void ModuleBitcodeWriter::writeGlobalValueSymbolTable(
3166 VSTOffset -= bitcodeStartBit();
3167 assert((VSTOffset & 31) == 0 &&
"VST block not 32-bit aligned");
3171 Stream.
BackpatchWord(VSTOffsetPlaceholder, VSTOffset / 32 + 1);
3175 auto Abbv = std::make_shared<BitCodeAbbrev>();
3184 if (
F.isDeclaration())
3191 uint64_t BitcodeIndex = FunctionToBitcodeIndex[&
F] - bitcodeStartBit();
3192 assert((BitcodeIndex & 31) == 0 &&
"function block not 32-bit aligned");
3196 Record[1] = BitcodeIndex / 32 + 1;
3205 void ModuleBitcodeWriter::writeFunctionLevelValueSymbolTable(
3220 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
3226 if (isa<BasicBlock>(
Name.getValue())) {
3229 AbbrevToUse = VST_BBENTRY_6_ABBREV;
3233 AbbrevToUse = VST_ENTRY_6_ABBREV;
3235 AbbrevToUse = VST_ENTRY_7_ABBREV;
3238 for (
const auto P :
Name.getKey())
3239 NameVals.push_back((
unsigned char)
P);
3242 Stream.
EmitRecord(Code, NameVals, AbbrevToUse);
3249 void ModuleBitcodeWriter::writeUseList(
UseListOrder &&Order) {
3250 assert(Order.Shuffle.size() >= 2 &&
"Shuffle too small");
3252 if (isa<BasicBlock>(Order.V))
3262 void ModuleBitcodeWriter::writeUseListBlock(
const Function *
F) {
3264 "Expected to be preserving use-list order");
3266 auto hasMore = [&]() {
3282 void ModuleBitcodeWriter::writeFunction(
3301 unsigned CstStart, CstEnd;
3303 writeConstants(CstStart, CstEnd,
false);
3306 writeFunctionMetadata(
F);
3309 unsigned InstID = CstEnd;
3311 bool NeedsMetadataAttachment =
F.hasMetadata();
3318 writeInstruction(*
I, InstID, Vals);
3320 if (!
I->getType()->isVoidTy())
3324 NeedsMetadataAttachment |=
I->hasMetadataOtherThanDebugLoc();
3337 Vals.push_back(
DL->getLine());
3338 Vals.push_back(
DL->getColumn());
3341 Vals.push_back(
DL->isImplicitCode());
3349 if (
auto *Symtab =
F.getValueSymbolTable())
3350 writeFunctionLevelValueSymbolTable(*Symtab);
3352 if (NeedsMetadataAttachment)
3353 writeFunctionMetadataAttachment(
F);
3355 writeUseListBlock(&
F);
3361 void ModuleBitcodeWriter::writeBlockInfo() {
3368 auto Abbv = std::make_shared<BitCodeAbbrev>();
3379 auto Abbv = std::make_shared<BitCodeAbbrev>();
3389 auto Abbv = std::make_shared<BitCodeAbbrev>();
3399 auto Abbv = std::make_shared<BitCodeAbbrev>();
3405 VST_BBENTRY_6_ABBREV)
3410 auto Abbv = std::make_shared<BitCodeAbbrev>();
3415 CONSTANTS_SETTYPE_ABBREV)
3420 auto Abbv = std::make_shared<BitCodeAbbrev>();
3424 CONSTANTS_INTEGER_ABBREV)
3429 auto Abbv = std::make_shared<BitCodeAbbrev>();
3437 CONSTANTS_CE_CAST_Abbrev)
3441 auto Abbv = std::make_shared<BitCodeAbbrev>();
3444 CONSTANTS_NULL_Abbrev)
3451 auto Abbv = std::make_shared<BitCodeAbbrev>();
3459 FUNCTION_INST_LOAD_ABBREV)
3463 auto Abbv = std::make_shared<BitCodeAbbrev>();
3468 FUNCTION_INST_UNOP_ABBREV)
3472 auto Abbv = std::make_shared<BitCodeAbbrev>();
3478 FUNCTION_INST_UNOP_FLAGS_ABBREV)
3482 auto Abbv = std::make_shared<BitCodeAbbrev>();
3488 FUNCTION_INST_BINOP_ABBREV)
3492 auto Abbv = std::make_shared<BitCodeAbbrev>();
3499 FUNCTION_INST_BINOP_FLAGS_ABBREV)
3503 auto Abbv = std::make_shared<BitCodeAbbrev>();
3510 FUNCTION_INST_CAST_ABBREV)
3515 auto Abbv = std::make_shared<BitCodeAbbrev>();
3518 FUNCTION_INST_RET_VOID_ABBREV)
3522 auto Abbv = std::make_shared<BitCodeAbbrev>();
3526 FUNCTION_INST_RET_VAL_ABBREV)
3530 auto Abbv = std::make_shared<BitCodeAbbrev>();
3533 FUNCTION_INST_UNREACHABLE_ABBREV)
3537 auto Abbv = std::make_shared<BitCodeAbbrev>();
3545 FUNCTION_INST_GEP_ABBREV)
3554 void IndexBitcodeWriter::writeModStrings() {
3560 auto Abbv = std::make_shared<BitCodeAbbrev>();
3568 Abbv = std::make_shared<BitCodeAbbrev>();
3576 Abbv = std::make_shared<BitCodeAbbrev>();
3584 Abbv = std::make_shared<BitCodeAbbrev>();
3595 [&](
const StringMapEntry<std::pair<uint64_t, ModuleHash>> &MPSE) {
3597 const auto &
Value = MPSE.getValue();
3599 unsigned AbbrevToUse = Abbrev8Bit;
3601 AbbrevToUse = Abbrev6Bit;
3603 AbbrevToUse = Abbrev7Bit;
3605 Vals.push_back(
Value.first);
3612 const auto &Hash =
Value.second;
3614 Vals.
assign(Hash.begin(), Hash.end());
3626 template <
typename Fn>
3630 if (!
FS->type_tests().empty())
3635 auto WriteVFuncIdVec = [&](uint64_t Ty,
3640 for (
auto &VF : VFs) {
3641 Record.push_back(VF.GUID);
3642 Record.push_back(VF.Offset);
3648 FS->type_test_assume_vcalls());
3650 FS->type_checked_load_vcalls());
3652 auto WriteConstVCallVec = [&](uint64_t Ty,
3654 for (
auto &
VC : VCs) {
3664 FS->type_test_assume_const_vcalls());
3666 FS->type_checked_load_const_vcalls());
3670 assert(Range.getLower().getNumWords() == 1);
3671 assert(Range.getUpper().getNumWords() == 1);
3676 if (!
FS->paramAccesses().empty()) {
3678 for (
auto &
Arg :
FS->paramAccesses()) {
3679 size_t UndoSize =
Record.size();
3681 WriteRange(
Arg.Use);
3683 for (
auto &Call :
Arg.Calls) {
3684 Record.push_back(Call.ParamNo);
3692 Record.push_back(*ValueID);
3693 WriteRange(Call.Offsets);
3704 std::set<GlobalValue::GUID> &ReferencedTypeIds) {
3705 if (!
FS->type_tests().empty())
3706 for (
auto &TT :
FS->type_tests())
3707 ReferencedTypeIds.insert(TT);
3709 auto GetReferencedTypesFromVFuncIdVec =
3711 for (
auto &VF : VFs)
3712 ReferencedTypeIds.insert(VF.GUID);
3715 GetReferencedTypesFromVFuncIdVec(
FS->type_test_assume_vcalls());
3716 GetReferencedTypesFromVFuncIdVec(
FS->type_checked_load_vcalls());
3718 auto GetReferencedTypesFromConstVCallVec =
3720 for (
auto &
VC : VCs)
3721 ReferencedTypeIds.insert(
VC.VFunc.GUID);
3724 GetReferencedTypesFromConstVCallVec(
FS->type_test_assume_const_vcalls());
3725 GetReferencedTypesFromConstVCallVec(
FS->type_checked_load_const_vcalls());
3731 NameVals.push_back(args.size());
3734 NameVals.push_back(ByArg.
TheKind);
3735 NameVals.push_back(ByArg.
Info);
3736 NameVals.push_back(ByArg.
Byte);
3737 NameVals.push_back(ByArg.
Bit);
3743 NameVals.push_back(
Id);
3745 NameVals.push_back(Wpd.
TheKind);
3749 NameVals.push_back(Wpd.
ResByArg.size());
3756 const std::string &
Id,
3758 NameVals.push_back(StrtabBuilder.
add(
Id));
3759 NameVals.push_back(
Id.size());
3768 for (
auto &
W : Summary.
WPDRes)
3777 NameVals.push_back(StrtabBuilder.
add(
Id));
3778 NameVals.push_back(
Id.size());
3780 for (
auto &
P : Summary) {
3781 NameVals.push_back(
P.AddressPointOffset);
3782 NameVals.push_back(VE.
getValueID(
P.VTableVI.getValue()));
3787 void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(
3789 unsigned ValueID,
unsigned FSCallsAbbrev,
unsigned FSCallsProfileAbbrev,
3791 NameVals.push_back(ValueID);
3800 auto SpecialRefCnts =
FS->specialRefCounts();
3802 NameVals.push_back(
FS->instCount());
3804 NameVals.push_back(
FS->refs().size());
3805 NameVals.push_back(SpecialRefCnts.first);
3806 NameVals.push_back(SpecialRefCnts.second);
3808 for (
auto &RI :
FS->refs())
3809 NameVals.push_back(VE.
getValueID(RI.getValue()));
3811 bool HasProfileData =
3813 for (
auto &ECI :
FS->calls()) {
3814 NameVals.push_back(getValueId(ECI.first));
3816 NameVals.push_back(
static_cast<uint8_t
>(ECI.second.Hotness));
3818 NameVals.push_back(ECI.second.RelBlockFreq);
3821 unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
3834 void ModuleBitcodeWriterBase::writeModuleLevelReferences(
3836 unsigned FSModRefsAbbrev,
unsigned FSModVTableRefsAbbrev) {
3838 if (!
VI ||
VI.getSummaryList().empty()) {
3844 auto *Summary =
VI.getSummaryList()[0].get();
3850 auto VTableFuncs =
VS->vTableFuncs();
3851 if (!VTableFuncs.empty())
3852 NameVals.push_back(
VS->refs().size());
3854 unsigned SizeBeforeRefs = NameVals.size();
3855 for (
auto &RI :
VS->refs())
3856 NameVals.push_back(VE.
getValueID(RI.getValue()));
3861 if (VTableFuncs.empty())
3866 for (
auto &
P : VTableFuncs) {
3867 NameVals.push_back(VE.
getValueID(
P.FuncVI.getValue()));
3868 NameVals.push_back(
P.VTableOffset);
3872 FSModVTableRefsAbbrev);
3879 void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
3882 bool IsThinLTO =
true;
3884 mdconst::extract_or_null<ConstantInt>(
M.getModuleFlag(
"ThinLTO")))
3885 IsThinLTO = MD->getZExtValue();
3897 if (
Index->enableSplitLTOUnit())
3906 for (
const auto &GVI : valueIds()) {
3912 auto Abbv = std::make_shared<BitCodeAbbrev>();
3927 Abbv = std::make_shared<BitCodeAbbrev>();
3945 Abbv = std::make_shared<BitCodeAbbrev>();
3954 Abbv = std::make_shared<BitCodeAbbrev>();
3965 Abbv = std::make_shared<BitCodeAbbrev>();
3973 Abbv = std::make_shared<BitCodeAbbrev>();
3992 if (!
VI ||
VI.getSummaryList().empty()) {
3998 auto *Summary =
VI.getSummaryList()[0].get();
3999 writePerModuleFunctionSummaryRecord(NameVals, Summary, VE.
getValueID(&
F),
4000 FSCallsAbbrev, FSCallsProfileAbbrev,
F);
4006 writeModuleLevelReferences(
G, NameVals, FSModRefsAbbrev,
4007 FSModVTableRefsAbbrev);
4010 auto *Aliasee =
A.getBaseObject();
4011 if (!Aliasee->hasName())
4016 NameVals.push_back(AliasId);
4017 auto *Summary =
Index->getGlobalValueSummary(A);
4020 NameVals.push_back(AliaseeId);
4025 for (
auto &
S :
Index->typeIdCompatibleVtableMap()) {
4029 TypeIdCompatibleVtableAbbrev);
4040 void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
4049 for (
const auto &GVI : valueIds()) {
4055 auto Abbv = std::make_shared<BitCodeAbbrev>();
4072 Abbv = std::make_shared<BitCodeAbbrev>();
4089 Abbv = std::make_shared<BitCodeAbbrev>();
4099 Abbv = std::make_shared<BitCodeAbbrev>();
4118 std::set<GlobalValue::GUID> ReferencedTypeIds;
4125 NameVals.push_back(
S.getOriginalName());
4130 std::set<GlobalValue::GUID> DefOrUseGUIDs;
4131 forEachSummary([&](GVInfo
I,
bool IsAliasee) {
4134 DefOrUseGUIDs.insert(
I.first);
4136 DefOrUseGUIDs.insert(
VI.getGUID());
4138 auto ValueId = getValueId(
I.first);
4140 SummaryToValueIdMap[
S] = *ValueId;
4148 if (
auto *AS = dyn_cast<AliasSummary>(
S)) {
4151 Aliases.push_back(AS);
4155 if (
auto *
VS = dyn_cast<GlobalVarSummary>(
S)) {
4156 NameVals.push_back(*ValueId);
4157 NameVals.push_back(
Index.getModuleId(
VS->modulePath()));
4160 for (
auto &RI :
VS->refs()) {
4161 auto RefValueId = getValueId(RI.getGUID());
4164 NameVals.push_back(*RefValueId);
4171 MaybeEmitOriginalName(*
S);
4183 GUID =
Index.getGUIDFromOriginalID(GUID);
4186 CallValueId = getValueId(GUID);
4199 auto *GVSum =
Index.getGlobalValueSummary(GUID,
false);
4205 auto *
FS = cast<FunctionSummary>(
S);
4209 NameVals.push_back(*ValueId);
4210 NameVals.push_back(
Index.getModuleId(
FS->modulePath()));
4212 NameVals.push_back(
FS->instCount());
4214 NameVals.push_back(
FS->entryCount());
4217 NameVals.push_back(0);
4218 NameVals.push_back(0);
4219 NameVals.push_back(0);
4221 unsigned Count = 0, RORefCnt = 0, WORefCnt = 0;
4222 for (
auto &RI :
FS->refs()) {
4223 auto RefValueId = getValueId(RI.getGUID());
4226 NameVals.push_back(*RefValueId);
4227 if (RI.isReadOnly())
4229 else if (RI.isWriteOnly())
4233 NameVals[6] = Count;
4234 NameVals[7] = RORefCnt;
4235 NameVals[8] = WORefCnt;
4237 bool HasProfileData =
false;
4238 for (
auto &EI :
FS->calls()) {
4245 for (
auto &EI :
FS->calls()) {
4251 NameVals.push_back(*CallValueId);
4253 NameVals.push_back(
static_cast<uint8_t
>(EI.second.Hotness));
4256 unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
4263 MaybeEmitOriginalName(*
S);
4266 for (
auto *AS : Aliases) {
4267 auto AliasValueId = SummaryToValueIdMap[AS];
4269 NameVals.push_back(AliasValueId);
4272 auto AliaseeValueId = SummaryToValueIdMap[&AS->
getAliasee()];
4274 NameVals.push_back(AliaseeValueId);
4279 MaybeEmitOriginalName(*AS);
4281 if (
auto *
FS = dyn_cast<FunctionSummary>(&AS->
getAliasee()))
4285 if (!
Index.cfiFunctionDefs().empty()) {
4286 for (
auto &
S :
Index.cfiFunctionDefs()) {
4287 if (DefOrUseGUIDs.count(
4289 NameVals.push_back(StrtabBuilder.
add(
S));
4290 NameVals.push_back(
S.size());
4293 if (!NameVals.empty()) {
4299 if (!
Index.cfiFunctionDecls().empty()) {
4300 for (
auto &
S :
Index.cfiFunctionDecls()) {
4301 if (DefOrUseGUIDs.count(
4303 NameVals.push_back(StrtabBuilder.
add(
S));
4304 NameVals.push_back(
S.size());
4307 if (!NameVals.empty()) {
4315 for (
auto &T : ReferencedTypeIds) {
4316 auto TidIter =
Index.typeIds().equal_range(T);
4317 for (
auto It = TidIter.first; It != TidIter.second; ++It) {
4337 auto Abbv = std::make_shared<BitCodeAbbrev>();
4343 "LLVM" LLVM_VERSION_STRING, StringAbbrev);
4346 Abbv = std::make_shared<BitCodeAbbrev>();
4355 void ModuleBitcodeWriter::writeModuleHash(
size_t BlockStartPos) {
4361 Buffer.size() - BlockStartPos));
4363 for (
int Pos = 0; Pos < 20; Pos += 4) {
4380 size_t BlockStartPos = Buffer.size();
4382 writeModuleVersion();
4391 writeAttributeGroupTable();
4394 writeAttributeTable();
4403 writeModuleConstants();
4406 writeModuleMetadataKinds();
4409 writeModuleMetadata();
4413 writeUseListBlock(
nullptr);
4415 writeOperandBundleTags();
4416 writeSyncScopeNames();
4421 if (!
F->isDeclaration())
4422 writeFunction(*
F, FunctionToBitcodeIndex);
4427 writePerModuleGlobalValueSummary();
4429 writeGlobalValueSymbolTable(FunctionToBitcodeIndex);
4431 writeModuleHash(BlockStartPos);
4464 DARWIN_CPU_ARCH_ABI64 = 0x01000000,
4465 DARWIN_CPU_TYPE_X86 = 7,
4466 DARWIN_CPU_TYPE_ARM = 12,
4467 DARWIN_CPU_TYPE_POWERPC = 18
4472 CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64;
4474 CPUType = DARWIN_CPU_TYPE_X86;
4476 CPUType = DARWIN_CPU_TYPE_POWERPC;
4478 CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;
4480 CPUType = DARWIN_CPU_TYPE_ARM;
4484 "Expected header size to be reserved");
4489 unsigned Position = 0;
4497 while (Buffer.size() & 15)
4498 Buffer.push_back(0);
4504 Stream.
Emit((
unsigned)
'B', 8);
4505 Stream.
Emit((
unsigned)
'C', 8);
4506 Stream.
Emit(0x0, 4);
4507 Stream.
Emit(0xC, 4);
4508 Stream.
Emit(0xE, 4);
4509 Stream.
Emit(0xD, 4);
4519 void BitcodeWriter::writeBlob(
unsigned Block,
unsigned Record,
StringRef Blob) {
4522 auto Abbv = std::make_shared<BitCodeAbbrev>();
4533 assert(!WroteStrtab && !WroteSymtab);
4539 if (
M->getModuleInlineAsm().empty())
4543 const Triple TT(
M->getTargetTriple());
4545 if (!
T || !
T->hasMCAsmParser())
4561 {Symtab.data(), Symtab.size()});
4567 std::vector<char> Strtab;
4569 Strtab.resize(StrtabBuilder.
getSize());
4570 StrtabBuilder.
write((uint8_t *)Strtab.data());
4573 {Strtab.data(), Strtab.size()});
4584 bool ShouldPreserveUseListOrder,
4594 Mods.push_back(
const_cast<Module *
>(&
M));
4596 ModuleBitcodeWriter ModuleWriter(
M, Buffer, StrtabBuilder, *Stream,
4597 ShouldPreserveUseListOrder,
Index,
4598 GenerateHash, ModHash);
4599 ModuleWriter.write();
4604 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
4605 IndexBitcodeWriter IndexWriter(*Stream, StrtabBuilder, *
Index,
4606 ModuleToSummariesForIndex);
4607 IndexWriter.write();
4612 bool ShouldPreserveUseListOrder,
4620 Triple TT(
M.getTargetTriple());
4621 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
4624 BitcodeWriter Writer(Buffer, dyn_cast<raw_fd_stream>(&Out));
4630 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
4634 if (!Buffer.empty())
4635 Out.
write((
char *)&Buffer.front(), Buffer.size());
4641 writeModuleVersion();
4647 writeCombinedGlobalValueSummary();
4658 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
4666 Out.
write((
char *)&Buffer.front(), Buffer.size());
4672 class ThinLinkBitcodeWriter :
public ModuleBitcodeWriterBase {
4682 : ModuleBitcodeWriterBase(
M, StrtabBuilder, Stream,
4684 ModHash(&ModHash) {}
4689 void writeSimplifiedModuleInfo();
4699 void ThinLinkBitcodeWriter::writeSimplifiedModuleInfo() {
4711 auto Abbv = std::make_shared<BitCodeAbbrev>();