34 #include "llvm/Config/llvm-config.h"
89 cl::desc(
"Number of metadatas above which we emit an index "
90 "to enable lazy-loading"));
93 cl::desc(
"The threshold (unit M) for flushing LLVM bitcode."));
97 cl::desc(
"Write relative block frequency to function summary "));
110 VST_BBENTRY_6_ABBREV,
114 CONSTANTS_INTEGER_ABBREV,
115 CONSTANTS_CE_CAST_Abbrev,
116 CONSTANTS_NULL_Abbrev,
120 FUNCTION_INST_UNOP_ABBREV,
121 FUNCTION_INST_UNOP_FLAGS_ABBREV,
122 FUNCTION_INST_BINOP_ABBREV,
123 FUNCTION_INST_BINOP_FLAGS_ABBREV,
124 FUNCTION_INST_CAST_ABBREV,
125 FUNCTION_INST_RET_VOID_ABBREV,
126 FUNCTION_INST_RET_VAL_ABBREV,
127 FUNCTION_INST_UNREACHABLE_ABBREV,
128 FUNCTION_INST_GEP_ABBREV,
133 class BitcodeWriterBase {
147 void writeModuleVersion();
150 void BitcodeWriterBase::writeModuleVersion() {
157 class ModuleBitcodeWriterBase :
public BitcodeWriterBase {
171 std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
174 unsigned GlobalValueId;
185 bool ShouldPreserveUseListOrder,
187 : BitcodeWriterBase(
Stream, StrtabBuilder),
M(
M),
197 for (
const auto &GUIDSummaryLists : *Index)
199 for (
auto &Summary : GUIDSummaryLists.second.SummaryList)
200 if (
auto FS = dyn_cast<FunctionSummary>(Summary.get()))
205 for (
auto &CallEdge :
FS->calls())
206 if (!CallEdge.first.haveGVs() || !CallEdge.first.getValue())
207 assignValueId(CallEdge.first.getGUID());
211 void writePerModuleGlobalValueSummary();
217 unsigned FSCallsAbbrev,
218 unsigned FSCallsProfileAbbrev,
222 unsigned FSModRefsAbbrev,
223 unsigned FSModVTableRefsAbbrev);
226 GUIDToValueIdMap[ValGUID] = ++GlobalValueId;
230 const auto &VMI = GUIDToValueIdMap.find(ValGUID);
233 assert(VMI != GUIDToValueIdMap.end() &&
234 "GUID does not have assigned value Id");
240 if (!
VI.haveGVs() || !
VI.getValue())
241 return getValueId(
VI.getGUID());
245 std::map<GlobalValue::GUID, unsigned> &valueIds() {
return GUIDToValueIdMap; }
249 class ModuleBitcodeWriter :
public ModuleBitcodeWriterBase {
273 : ModuleBitcodeWriterBase(
M, StrtabBuilder,
Stream,
274 ShouldPreserveUseListOrder,
Index),
275 Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash),
276 BitcodeStartBit(
Stream.GetCurrentBitNo()) {}
282 uint64_t bitcodeStartBit() {
return BitcodeStartBit; }
286 void writeAttributeGroupTable();
287 void writeAttributeTable();
288 void writeTypeTable();
290 void writeValueSymbolTableForwardDecl();
291 void writeModuleInfo();
296 unsigned createDILocationAbbrev();
299 unsigned createGenericDINodeAbbrev();
366 unsigned createNamedMetadataAbbrev();
368 unsigned createMetadataStringsAbbrev();
373 std::vector<unsigned> *MDAbbrevs =
nullptr,
374 std::vector<uint64_t> *IndexPos =
nullptr);
375 void writeModuleMetadata();
376 void writeFunctionMetadata(
const Function &
F);
377 void writeFunctionMetadataAttachment(
const Function &
F);
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)
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:
550 case Instruction::FDiv:
553 case Instruction::FRem:
608 Stream.EmitRecord(Code, Vals, AbbrevToUse);
613 case Attribute::Alignment:
615 case Attribute::AllocAlign:
617 case Attribute::AllocSize:
619 case Attribute::AlwaysInline:
621 case Attribute::ArgMemOnly:
623 case Attribute::Builtin:
625 case Attribute::ByVal:
629 case Attribute::InAlloca:
633 case Attribute::DisableSanitizerInstrumentation:
637 case Attribute::ElementType:
639 case Attribute::InaccessibleMemOnly:
641 case Attribute::InaccessibleMemOrArgMemOnly:
643 case Attribute::InlineHint:
645 case Attribute::InReg:
649 case Attribute::MinSize:
651 case Attribute::AllocatedPointer:
653 case Attribute::Naked:
655 case Attribute::Nest:
657 case Attribute::NoAlias:
659 case Attribute::NoBuiltin:
661 case Attribute::NoCallback:
663 case Attribute::NoCapture:
665 case Attribute::NoDuplicate:
667 case Attribute::NoFree:
669 case Attribute::NoImplicitFloat:
671 case Attribute::NoInline:
673 case Attribute::NoRecurse:
675 case Attribute::NoMerge:
677 case Attribute::NonLazyBind:
679 case Attribute::NonNull:
681 case Attribute::Dereferenceable:
683 case Attribute::DereferenceableOrNull:
685 case Attribute::NoRedZone:
687 case Attribute::NoReturn:
689 case Attribute::NoSync:
691 case Attribute::NoCfCheck:
693 case Attribute::NoProfile:
695 case Attribute::NoUnwind:
697 case Attribute::NoSanitizeBounds:
699 case Attribute::NoSanitizeCoverage:
701 case Attribute::NullPointerIsValid:
703 case Attribute::OptForFuzzing:
705 case Attribute::OptimizeForSize:
707 case Attribute::OptimizeNone:
709 case Attribute::ReadNone:
711 case Attribute::ReadOnly:
713 case Attribute::Returned:
715 case Attribute::ReturnsTwice:
717 case Attribute::SExt:
719 case Attribute::Speculatable:
721 case Attribute::StackAlignment:
723 case Attribute::StackProtect:
725 case Attribute::StackProtectReq:
727 case Attribute::StackProtectStrong:
729 case Attribute::SafeStack:
731 case Attribute::ShadowCallStack:
733 case Attribute::StrictFP:
735 case Attribute::StructRet:
737 case Attribute::SanitizeAddress:
739 case Attribute::SanitizeHWAddress:
741 case Attribute::SanitizeThread:
743 case Attribute::SanitizeMemory:
745 case Attribute::SpeculativeLoadHardening:
747 case Attribute::SwiftError:
749 case Attribute::SwiftSelf:
751 case Attribute::SwiftAsync:
753 case Attribute::UWTable:
755 case Attribute::VScaleRange:
757 case Attribute::WillReturn:
759 case Attribute::WriteOnly:
761 case Attribute::ZExt:
763 case Attribute::ImmArg:
765 case Attribute::SanitizeMemTag:
767 case Attribute::Preallocated:
769 case Attribute::NoUndef:
771 case Attribute::ByRef:
773 case Attribute::MustProgress:
787 void ModuleBitcodeWriter::writeAttributeGroupTable() {
788 const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
790 if (AttrGrps.empty())
return;
796 unsigned AttrListIndex = Pair.first;
799 Record.push_back(AttrListIndex);
802 if (Attr.isEnumAttribute()) {
805 }
else if (Attr.isIntAttribute()) {
808 Record.push_back(Attr.getValueAsInt());
809 }
else if (Attr.isStringAttribute()) {
821 assert(Attr.isTypeAttribute());
822 Type *Ty = Attr.getValueAsType();
823 Record.push_back(Ty ? 6 : 5);
837 void ModuleBitcodeWriter::writeAttributeTable() {
845 for (
unsigned i :
AL.indexes()) {
859 void ModuleBitcodeWriter::writeTypeTable() {
868 auto Abbv = std::make_shared<BitCodeAbbrev>();
875 Abbv = std::make_shared<BitCodeAbbrev>();
881 Abbv = std::make_shared<BitCodeAbbrev>();
889 Abbv = std::make_shared<BitCodeAbbrev>();
897 Abbv = std::make_shared<BitCodeAbbrev>();
904 Abbv = std::make_shared<BitCodeAbbrev>();
912 Abbv = std::make_shared<BitCodeAbbrev>();
919 TypeVals.push_back(TypeList.size());
924 for (
Type *
T : TypeList) {
928 switch (
T->getTypeID()) {
945 TypeVals.push_back(cast<IntegerType>(
T)->
getBitWidth());
955 AbbrevToUse = OpaquePtrAbbrev;
962 AbbrevToUse = PtrAbbrev;
974 AbbrevToUse = FunctionAbbrev;
980 TypeVals.push_back(
ST->isPacked());
982 for (
Type *ET :
ST->elements())
985 if (
ST->isLiteral()) {
987 AbbrevToUse = StructAnonAbbrev;
989 if (
ST->isOpaque()) {
993 AbbrevToUse = StructNamedAbbrev;
997 if (!
ST->getName().empty())
1009 AbbrevToUse = ArrayAbbrev;
1020 if (isa<ScalableVectorType>(VT))
1021 TypeVals.push_back(
true);
1029 Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
1089 RawFlags |= (Flags.
Live << 1);
1096 RawFlags = (RawFlags << 4) | Flags.
Linkage;
1139 switch (
C.getSelectionKind()) {
1163 size_t ModuleBitcodeWriter::addToStrtab(
StringRef Str) {
1166 return StrtabBuilder.
add(Str);
1169 void ModuleBitcodeWriter::writeComdats() {
1173 Vals.push_back(addToStrtab(
C->getName()));
1174 Vals.push_back(
C->getName().size());
1184 void ModuleBitcodeWriter::writeValueSymbolTableForwardDecl() {
1189 auto Abbv = std::make_shared<BitCodeAbbrev>();
1199 Stream.EmitRecordWithAbbrev(VSTOffsetAbbrev, Vals);
1204 VSTOffsetPlaceholder =
Stream.GetCurrentBitNo() - 32;
1211 bool isChar6 =
true;
1212 for (
char C : Str) {
1215 if ((
unsigned char)
C & 128)
1227 void ModuleBitcodeWriter::writeModuleInfo() {
1229 if (!
M.getTargetTriple().empty())
1232 const std::string &
DL =
M.getDataLayoutStr();
1235 if (!
M.getModuleInlineAsm().empty())
1241 std::map<std::string, unsigned> SectionMap;
1242 std::map<std::string, unsigned> GCMap;
1244 unsigned MaxGlobalType = 0;
1245 const auto UpdateMaxAlignment = [&MaxAlignment](
const MaybeAlign A) {
1247 MaxAlignment = !MaxAlignment ? *
A :
std::max(*MaxAlignment, *A);
1250 UpdateMaxAlignment(GV.getAlign());
1252 if (GV.hasSection()) {
1254 unsigned &Entry = SectionMap[std::string(GV.getSection())];
1258 Entry = SectionMap.size();
1263 UpdateMaxAlignment(
F.getAlign());
1264 if (
F.hasSection()) {
1266 unsigned &Entry = SectionMap[std::string(
F.getSection())];
1270 Entry = SectionMap.size();
1275 unsigned &Entry = GCMap[
F.getGC()];
1279 Entry = GCMap.size();
1285 unsigned SimpleGVarAbbrev = 0;
1286 if (!
M.global_empty()) {
1288 auto Abbv = std::make_shared<BitCodeAbbrev>();
1302 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1306 if (SectionMap.empty())
1326 auto Abbv = std::make_shared<BitCodeAbbrev>();
1329 Abbv->Add(AbbrevOpToUse);
1332 for (
const auto P :
M.getSourceFileName())
1333 Vals.push_back((
unsigned char)
P);
1342 unsigned AbbrevToUse = 0;
1348 Vals.push_back(addToStrtab(GV.getName()));
1349 Vals.push_back(GV.getName().size());
1350 Vals.push_back(VE.
getTypeID(GV.getValueType()));
1351 Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
1352 Vals.push_back(GV.isDeclaration() ? 0 :
1355 Vals.push_back(getEncodedAlign(GV.getAlign()));
1356 Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1358 if (GV.isThreadLocal() ||
1361 GV.isExternallyInitialized() ||
1364 GV.hasAttributes() ||
1366 GV.hasPartition()) {
1370 Vals.push_back(GV.isExternallyInitialized());
1372 Vals.push_back(GV.hasComdat() ? VE.
getComdatID(GV.getComdat()) : 0);
1377 Vals.push_back(GV.isDSOLocal());
1378 Vals.push_back(addToStrtab(GV.getPartition()));
1379 Vals.push_back(GV.getPartition().size());
1381 AbbrevToUse = SimpleGVarAbbrev;
1394 Vals.push_back(addToStrtab(
F.getName()));
1395 Vals.push_back(
F.getName().size());
1396 Vals.push_back(VE.
getTypeID(
F.getFunctionType()));
1397 Vals.push_back(
F.getCallingConv());
1398 Vals.push_back(
F.isDeclaration());
1401 Vals.push_back(getEncodedAlign(
F.getAlign()));
1402 Vals.push_back(
F.hasSection() ? SectionMap[std::string(
F.getSection())]
1405 Vals.push_back(
F.hasGC() ? GCMap[
F.getGC()] : 0);
1407 Vals.push_back(
F.hasPrologueData() ? (VE.
getValueID(
F.getPrologueData()) + 1)
1410 Vals.push_back(
F.hasComdat() ? VE.
getComdatID(
F.getComdat()) : 0);
1411 Vals.push_back(
F.hasPrefixData() ? (VE.
getValueID(
F.getPrefixData()) + 1)
1414 F.hasPersonalityFn() ? (VE.
getValueID(
F.getPersonalityFn()) + 1) : 0);
1416 Vals.push_back(
F.isDSOLocal());
1417 Vals.push_back(
F.getAddressSpace());
1418 Vals.push_back(addToStrtab(
F.getPartition()));
1419 Vals.push_back(
F.getPartition().size());
1421 unsigned AbbrevToUse = 0;
1431 Vals.push_back(addToStrtab(
A.getName()));
1432 Vals.push_back(
A.getName().size());
1433 Vals.push_back(VE.
getTypeID(
A.getValueType()));
1434 Vals.push_back(
A.getType()->getAddressSpace());
1441 Vals.push_back(
A.isDSOLocal());
1442 Vals.push_back(addToStrtab(
A.getPartition()));
1443 Vals.push_back(
A.getPartition().size());
1445 unsigned AbbrevToUse = 0;
1454 Vals.push_back(addToStrtab(
I.getName()));
1455 Vals.push_back(
I.getName().size());
1456 Vals.push_back(VE.
getTypeID(
I.getValueType()));
1457 Vals.push_back(
I.getType()->getAddressSpace());
1461 Vals.push_back(
I.isDSOLocal());
1462 Vals.push_back(addToStrtab(
I.getPartition()));
1463 Vals.push_back(
I.getPartition().size());
1468 writeValueSymbolTableForwardDecl();
1474 if (
const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
1475 if (OBO->hasNoSignedWrap())
1477 if (OBO->hasNoUnsignedWrap())
1479 }
else if (
const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
1482 }
else if (
const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
1483 if (FPMO->hasAllowReassoc())
1485 if (FPMO->hasNoNaNs())
1487 if (FPMO->hasNoInfs())
1489 if (FPMO->hasNoSignedZeros())
1491 if (FPMO->hasAllowReciprocal())
1493 if (FPMO->hasAllowContract())
1495 if (FPMO->hasApproxFunc())
1502 void ModuleBitcodeWriter::writeValueAsMetadata(
1515 for (
unsigned i = 0,
e =
N->getNumOperands();
i !=
e; ++
i) {
1517 assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1518 "Unexpected function-local metadata");
1527 unsigned ModuleBitcodeWriter::createDILocationAbbrev() {
1530 auto Abbv = std::make_shared<BitCodeAbbrev>();
1545 Abbrev = createDILocationAbbrev();
1547 Record.push_back(
N->isDistinct());
1548 Record.push_back(
N->getLine());
1549 Record.push_back(
N->getColumn());
1552 Record.push_back(
N->isImplicitCode());
1558 unsigned ModuleBitcodeWriter::createGenericDINodeAbbrev() {
1561 auto Abbv = std::make_shared<BitCodeAbbrev>();
1576 Abbrev = createGenericDINodeAbbrev();
1578 Record.push_back(
N->isDistinct());
1579 Record.push_back(
N->getTag());
1582 for (
auto &
I :
N->operands())
1617 if ((int64_t)V >= 0)
1618 Vals.push_back(V << 1);
1620 Vals.push_back((-V << 1) | 1);
1628 unsigned NumWords = A.getActiveWords();
1629 const uint64_t *RawData = A.getRawData();
1630 for (
unsigned i = 0;
i < NumWords;
i++)
1638 Record.push_back(IsBigInt | (
N->isUnsigned() << 1) |
N->isDistinct());
1639 Record.push_back(
N->getValue().getBitWidth());
1650 Record.push_back(
N->isDistinct());
1651 Record.push_back(
N->getTag());
1653 Record.push_back(
N->getSizeInBits());
1654 Record.push_back(
N->getAlignInBits());
1655 Record.push_back(
N->getEncoding());
1656 Record.push_back(
N->getFlags());
1665 Record.push_back(
N->isDistinct());
1666 Record.push_back(
N->getTag());
1671 Record.push_back(
N->getSizeInBits());
1672 Record.push_back(
N->getAlignInBits());
1673 Record.push_back(
N->getEncoding());
1682 Record.push_back(
N->isDistinct());
1683 Record.push_back(
N->getTag());
1686 Record.push_back(
N->getLine());
1689 Record.push_back(
N->getSizeInBits());
1690 Record.push_back(
N->getAlignInBits());
1691 Record.push_back(
N->getOffsetInBits());
1692 Record.push_back(
N->getFlags());
1697 if (
const auto &DWARFAddressSpace =
N->getDWARFAddressSpace())
1698 Record.push_back(*DWARFAddressSpace + 1);
1711 const unsigned IsNotUsedInOldTypeRef = 0x2;
1712 Record.push_back(IsNotUsedInOldTypeRef | (
unsigned)
N->isDistinct());
1713 Record.push_back(
N->getTag());
1716 Record.push_back(
N->getLine());
1719 Record.push_back(
N->getSizeInBits());
1720 Record.push_back(
N->getAlignInBits());
1721 Record.push_back(
N->getOffsetInBits());
1722 Record.push_back(
N->getFlags());
1724 Record.push_back(
N->getRuntimeLang());
1742 const unsigned HasNoOldTypeRefs = 0x2;
1743 Record.push_back(HasNoOldTypeRefs | (
unsigned)
N->isDistinct());
1744 Record.push_back(
N->getFlags());
1755 Record.push_back(
N->isDistinct());
1758 if (
N->getRawChecksum()) {
1759 Record.push_back(
N->getRawChecksum()->Kind);
1767 auto Source =
N->getRawSource();
1778 assert(
N->isDistinct() &&
"Expected distinct compile units");
1780 Record.push_back(
N->getSourceLanguage());
1783 Record.push_back(
N->isOptimized());
1785 Record.push_back(
N->getRuntimeVersion());
1787 Record.push_back(
N->getEmissionKind());
1793 Record.push_back(
N->getDWOId());
1795 Record.push_back(
N->getSplitDebugInlining());
1796 Record.push_back(
N->getDebugInfoForProfiling());
1797 Record.push_back((
unsigned)
N->getNameTableKind());
1798 Record.push_back(
N->getRangesBaseAddress());
1809 const uint64_t HasUnitFlag = 1 << 1;
1810 const uint64_t HasSPFlagsFlag = 1 << 2;
1811 Record.push_back(
uint64_t(
N->isDistinct()) | HasUnitFlag | HasSPFlagsFlag);
1816 Record.push_back(
N->getLine());
1818 Record.push_back(
N->getScopeLine());
1820 Record.push_back(
N->getSPFlags());
1821 Record.push_back(
N->getVirtualIndex());
1822 Record.push_back(
N->getFlags());
1827 Record.push_back(
N->getThisAdjustment());
1839 Record.push_back(
N->isDistinct());
1842 Record.push_back(
N->getLine());
1843 Record.push_back(
N->getColumn());
1852 Record.push_back(
N->isDistinct());
1855 Record.push_back(
N->getDiscriminator());
1864 Record.push_back(
N->isDistinct());
1869 Record.push_back(
N->getLineNo());
1878 Record.push_back(
N->isDistinct() |
N->getExportSymbols() << 1);
1889 Record.push_back(
N->isDistinct());
1890 Record.push_back(
N->getMacinfoType());
1891 Record.push_back(
N->getLine());
1902 Record.push_back(
N->isDistinct());
1903 Record.push_back(
N->getMacinfoType());
1904 Record.push_back(
N->getLine());
1915 Record.reserve(
N->getArgs().size());
1926 Record.push_back(
N->isDistinct());
1927 for (
auto &
I :
N->operands())
1929 Record.push_back(
N->getLineNo());
1930 Record.push_back(
N->getIsDecl());
1939 Record.push_back(
N->isDistinct());
1942 Record.push_back(
N->isDefault());
1951 Record.push_back(
N->isDistinct());
1952 Record.push_back(
N->getTag());
1955 Record.push_back(
N->isDefault());
1971 Record.push_back(
N->getLine());
1973 Record.push_back(
N->isLocalToUnit());
1974 Record.push_back(
N->isDefinition());
1977 Record.push_back(
N->getAlignInBits());
2000 const uint64_t HasAlignmentFlag = 1 << 1;
2005 Record.push_back(
N->getLine());
2007 Record.push_back(
N->getArg());
2008 Record.push_back(
N->getFlags());
2009 Record.push_back(
N->getAlignInBits());
2023 Record.push_back(
N->getLine());
2032 Record.reserve(
N->getElements().size() + 1);
2035 Record.append(
N->elements_begin(),
N->elements_end());
2044 Record.push_back(
N->isDistinct());
2055 Record.push_back(
N->isDistinct());
2058 Record.push_back(
N->getLine());
2061 Record.push_back(
N->getAttributes());
2071 Record.push_back(
N->isDistinct());
2072 Record.push_back(
N->getTag());
2075 Record.push_back(
N->getLine());
2084 unsigned ModuleBitcodeWriter::createNamedMetadataAbbrev() {
2085 auto Abbv = std::make_shared<BitCodeAbbrev>();
2092 void ModuleBitcodeWriter::writeNamedMetadata(
2094 if (
M.named_metadata_empty())
2097 unsigned Abbrev = createNamedMetadataAbbrev();
2101 Record.append(Str.bytes_begin(), Str.bytes_end());
2106 for (
const MDNode *
N : NMD.operands())
2113 unsigned ModuleBitcodeWriter::createMetadataStringsAbbrev() {
2114 auto Abbv = std::make_shared<BitCodeAbbrev>();
2126 void ModuleBitcodeWriter::writeMetadataStrings(
2128 if (Strings.empty())
2133 Record.push_back(Strings.size());
2140 W.EmitVBR(cast<MDString>(MD)->getLength(), 6);
2145 Record.push_back(Blob.size());
2149 Blob.
append(cast<MDString>(MD)->getString());
2152 Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(),
Record, Blob);
2158 #define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
2159 #include "llvm/IR/Metadata.def"
2163 void ModuleBitcodeWriter::writeMetadataRecords(
2165 std::vector<unsigned> *MDAbbrevs, std::vector<uint64_t> *IndexPos) {
2170 #define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
2171 #include "llvm/IR/Metadata.def"
2175 IndexPos->push_back(
Stream.GetCurrentBitNo());
2176 if (
const MDNode *
N = dyn_cast<MDNode>(MD)) {
2177 assert(
N->isResolved() &&
"Expected forward references to be resolved");
2179 switch (
N->getMetadataID()) {
2182 #define HANDLE_MDNODE_LEAF(CLASS) \
2183 case Metadata::CLASS##Kind: \
2185 write##CLASS(cast<CLASS>(N), Record, \
2186 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
2188 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
2190 #include "llvm/IR/Metadata.def"
2193 writeValueAsMetadata(cast<ValueAsMetadata>(MD),
Record);
2197 void ModuleBitcodeWriter::writeModuleMetadata() {
2198 if (!VE.
hasMDs() &&
M.named_metadata_empty())
2206 std::vector<unsigned> MDAbbrevs;
2209 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
2210 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
2211 createGenericDINodeAbbrev();
2213 auto Abbv = std::make_shared<BitCodeAbbrev>();
2219 Abbv = std::make_shared<BitCodeAbbrev>();
2245 std::vector<uint64_t> IndexPos;
2256 Stream.BackpatchWord64(IndexOffsetRecordBitPos - 64,
2257 Stream.GetCurrentBitNo() - IndexOffsetRecordBitPos);
2260 uint64_t PreviousValue = IndexOffsetRecordBitPos;
2261 for (
auto &Elt : IndexPos) {
2262 auto EltDelta = Elt - PreviousValue;
2263 PreviousValue = Elt;
2272 writeNamedMetadata(
Record);
2274 auto AddDeclAttachedMetadata = [&](
const GlobalObject &GO) {
2277 pushGlobalMetadataAttachment(
Record, GO);
2281 if (
F.isDeclaration() &&
F.hasMetadata())
2282 AddDeclAttachedMetadata(
F);
2286 if (GV.hasMetadata())
2287 AddDeclAttachedMetadata(GV);
2292 void ModuleBitcodeWriter::writeFunctionMetadata(
const Function &
F) {
2303 void ModuleBitcodeWriter::pushGlobalMetadataAttachment(
2308 for (
const auto &
I : MDs) {
2314 void ModuleBitcodeWriter::writeFunctionMetadataAttachment(
const Function &
F) {
2319 if (
F.hasMetadata()) {
2320 pushGlobalMetadataAttachment(
Record,
F);
2331 I.getAllMetadataOtherThanDebugLoc(MDs);
2334 if (MDs.empty())
continue;
2338 for (
unsigned i = 0,
e = MDs.size();
i !=
e; ++
i) {
2339 Record.push_back(MDs[
i].first);
2349 void ModuleBitcodeWriter::writeModuleMetadataKinds() {
2355 M.getMDKindNames(Names);
2357 if (Names.empty())
return;
2361 for (
unsigned MDKindID = 0,
e = Names.size(); MDKindID !=
e; ++MDKindID) {
2362 Record.push_back(MDKindID);
2373 void ModuleBitcodeWriter::writeOperandBundleTags() {
2381 M.getOperandBundleTags(Tags);
2390 for (
auto Tag : Tags) {
2400 void ModuleBitcodeWriter::writeSyncScopeNames() {
2402 M.getContext().getSyncScopeNames(SSNs);
2409 for (
auto SSN : SSNs) {
2410 Record.append(SSN.begin(), SSN.end());
2418 void ModuleBitcodeWriter::writeConstants(
unsigned FirstVal,
unsigned LastVal,
2420 if (FirstVal == LastVal)
return;
2424 unsigned AggregateAbbrev = 0;
2425 unsigned String8Abbrev = 0;
2426 unsigned CString7Abbrev = 0;
2427 unsigned CString6Abbrev = 0;
2431 auto Abbv = std::make_shared<BitCodeAbbrev>();
2438 Abbv = std::make_shared<BitCodeAbbrev>();
2444 Abbv = std::make_shared<BitCodeAbbrev>();
2450 Abbv = std::make_shared<BitCodeAbbrev>();
2460 Type *LastTy =
nullptr;
2461 for (
unsigned i = FirstVal;
i != LastVal; ++
i) {
2462 const Value *V = Vals[
i].first;
2468 CONSTANTS_SETTYPE_ABBREV);
2472 if (
const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2475 unsigned(IA->hasSideEffects()) |
unsigned(IA->isAlignStack()) << 1 |
2476 unsigned(IA->getDialect() & 1) << 2 |
unsigned(IA->canThrow()) << 3);
2479 const std::string &AsmStr = IA->getAsmString();
2480 Record.push_back(AsmStr.size());
2481 Record.append(AsmStr.begin(), AsmStr.end());
2484 const std::string &ConstraintStr = IA->getConstraintString();
2485 Record.push_back(ConstraintStr.size());
2486 Record.append(ConstraintStr.begin(), ConstraintStr.end());
2492 unsigned Code = -1U;
2493 unsigned AbbrevToUse = 0;
2494 if (
C->isNullValue()) {
2496 }
else if (isa<PoisonValue>(
C)) {
2498 }
else if (isa<UndefValue>(
C)) {
2501 if (
IV->getBitWidth() <= 64) {
2505 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2510 }
else if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(
C)) {
2512 Type *Ty = CFP->getType();
2515 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2519 APInt api = CFP->getValueAPF().bitcastToAPInt();
2521 Record.push_back((
p[1] << 48) | (
p[0] >> 16));
2522 Record.push_back(
p[0] & 0xffffLL);
2524 APInt api = CFP->getValueAPF().bitcastToAPInt();
2529 assert(0 &&
"Unknown FP type!");
2531 }
else if (isa<ConstantDataSequential>(
C) &&
2532 cast<ConstantDataSequential>(
C)->isString()) {
2535 unsigned NumElts = Str->getNumElements();
2537 if (Str->isCString()) {
2542 AbbrevToUse = String8Abbrev;
2546 for (
unsigned i = 0;
i != NumElts; ++
i) {
2547 unsigned char V = Str->getElementAsInteger(
i);
2549 isCStr7 &= (V & 128) == 0;
2555 AbbrevToUse = CString6Abbrev;
2557 AbbrevToUse = CString7Abbrev;
2559 dyn_cast<ConstantDataSequential>(
C)) {
2561 Type *EltTy = CDS->getElementType();
2562 if (isa<IntegerType>(EltTy)) {
2563 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i)
2564 Record.push_back(CDS->getElementAsInteger(
i));
2566 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i)
2568 CDS->getElementAsAPFloat(
i).bitcastToAPInt().getLimitedValue());
2570 }
else if (isa<ConstantAggregate>(
C)) {
2572 for (
const Value *
Op :
C->operands())
2574 AbbrevToUse = AggregateAbbrev;
2575 }
else if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(
C)) {
2576 switch (
CE->getOpcode()) {
2583 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2585 assert(
CE->getNumOperands() == 2 &&
"Unknown constant expr!");
2595 case Instruction::FNeg: {
2596 assert(
CE->getNumOperands() == 1 &&
"Unknown constant expr!");
2605 case Instruction::GetElementPtr: {
2607 const auto *GO = cast<GEPOperator>(
C);
2611 Record.push_back((*Idx << 1) | GO->isInBounds());
2612 }
else if (GO->isInBounds())
2614 for (
unsigned i = 0,
e =
CE->getNumOperands();
i !=
e; ++
i) {
2626 case Instruction::ExtractElement:
2633 case Instruction::InsertElement:
2640 case Instruction::ShuffleVector:
2645 if (
C->getType() ==
C->getOperand(0)->getType()) {
2655 case Instruction::ICmp:
2656 case Instruction::FCmp:
2661 Record.push_back(
CE->getPredicate());
2663 case Instruction::ExtractValue:
2664 case Instruction::InsertValue:
2668 }
else if (
const BlockAddress *BA = dyn_cast<BlockAddress>(
C)) {
2673 }
else if (
const auto *Equiv = dyn_cast<DSOLocalEquivalent>(
C)) {
2677 }
else if (
const auto *
NC = dyn_cast<NoCFIValue>(
C)) {
2694 void ModuleBitcodeWriter::writeModuleConstants() {
2699 for (
unsigned i = 0,
e = Vals.size();
i !=
e; ++
i) {
2700 if (!isa<GlobalValue>(Vals[
i].first)) {
2701 writeConstants(
i, Vals.size(),
true);
2715 bool ModuleBitcodeWriter::pushValueAndType(
const Value *V,
unsigned InstID,
2719 Vals.push_back(InstID -
ValID);
2720 if (
ValID >= InstID) {
2727 void ModuleBitcodeWriter::writeOperandBundles(
const CallBase &CS,
2734 Record.push_back(
C.getOperandBundleTagID(Bundle.getTagName()));
2736 for (
auto &Input : Bundle.Inputs)
2737 pushValueAndType(Input, InstID,
Record);
2746 void ModuleBitcodeWriter::pushValue(
const Value *V,
unsigned InstID,
2749 Vals.push_back(InstID -
ValID);
2752 void ModuleBitcodeWriter::pushValueSigned(
const Value *V,
unsigned InstID,
2755 int64_t diff = ((int32_t)InstID - (int32_t)
ValID);
2760 void ModuleBitcodeWriter::writeInstruction(
const Instruction &
I,
2764 unsigned AbbrevToUse = 0;
2766 switch (
I.getOpcode()) {
2770 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2771 AbbrevToUse = FUNCTION_INST_CAST_ABBREV;
2775 assert(isa<BinaryOperator>(
I) &&
"Unknown instruction!");
2777 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2778 AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;
2779 pushValue(
I.getOperand(1), InstID, Vals);
2783 if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)
2784 AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;
2785 Vals.push_back(Flags);
2789 case Instruction::FNeg: {
2791 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2792 AbbrevToUse = FUNCTION_INST_UNOP_ABBREV;
2796 if (AbbrevToUse == FUNCTION_INST_UNOP_ABBREV)
2797 AbbrevToUse = FUNCTION_INST_UNOP_FLAGS_ABBREV;
2798 Vals.push_back(Flags);
2802 case Instruction::GetElementPtr: {
2804 AbbrevToUse = FUNCTION_INST_GEP_ABBREV;
2805 auto &GEPInst = cast<GetElementPtrInst>(
I);
2806 Vals.push_back(GEPInst.isInBounds());
2807 Vals.push_back(VE.
getTypeID(GEPInst.getSourceElementType()));
2808 for (
unsigned i = 0,
e =
I.getNumOperands();
i !=
e; ++
i)
2809 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2812 case Instruction::ExtractValue: {
2814 pushValueAndType(
I.getOperand(0), InstID, Vals);
2819 case Instruction::InsertValue: {
2821 pushValueAndType(
I.getOperand(0), InstID, Vals);
2822 pushValueAndType(
I.getOperand(1), InstID, Vals);
2829 pushValueAndType(
I.getOperand(1), InstID, Vals);
2830 pushValue(
I.getOperand(2), InstID, Vals);
2831 pushValueAndType(
I.getOperand(0), InstID, Vals);
2834 Vals.push_back(Flags);
2837 case Instruction::ExtractElement:
2839 pushValueAndType(
I.getOperand(0), InstID, Vals);
2840 pushValueAndType(
I.getOperand(1), InstID, Vals);
2842 case Instruction::InsertElement:
2844 pushValueAndType(
I.getOperand(0), InstID, Vals);
2845 pushValue(
I.getOperand(1), InstID, Vals);
2846 pushValueAndType(
I.getOperand(2), InstID, Vals);
2848 case Instruction::ShuffleVector:
2850 pushValueAndType(
I.getOperand(0), InstID, Vals);
2851 pushValue(
I.getOperand(1), InstID, Vals);
2852 pushValue(cast<ShuffleVectorInst>(
I).getShuffleMaskForBitcode(), InstID,
2855 case Instruction::ICmp:
2856 case Instruction::FCmp: {
2859 pushValueAndType(
I.getOperand(0), InstID, Vals);
2860 pushValue(
I.getOperand(1), InstID, Vals);
2864 Vals.push_back(Flags);
2871 unsigned NumOperands =
I.getNumOperands();
2872 if (NumOperands == 0)
2873 AbbrevToUse = FUNCTION_INST_RET_VOID_ABBREV;
2874 else if (NumOperands == 1) {
2875 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2876 AbbrevToUse = FUNCTION_INST_RET_VAL_ABBREV;
2878 for (
unsigned i = 0,
e = NumOperands;
i !=
e; ++
i)
2879 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2883 case Instruction::Br:
2894 case Instruction::Switch:
2898 Vals.push_back(VE.
getTypeID(
SI.getCondition()->getType()));
2899 pushValue(
SI.getCondition(), InstID, Vals);
2901 for (
auto Case :
SI.cases()) {
2902 Vals.push_back(VE.
getValueID(Case.getCaseValue()));
2903 Vals.push_back(VE.
getValueID(Case.getCaseSuccessor()));
2907 case Instruction::IndirectBr:
2909 Vals.push_back(VE.
getTypeID(
I.getOperand(0)->getType()));
2911 pushValue(
I.getOperand(0), InstID, Vals);
2912 for (
unsigned i = 1,
e =
I.getNumOperands();
i !=
e; ++
i)
2916 case Instruction::Invoke: {
2922 writeOperandBundles(*II, InstID);
2931 pushValueAndType(Callee, InstID, Vals);
2935 pushValue(
I.getOperand(
i), InstID, Vals);
2940 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2944 case Instruction::Resume:
2946 pushValueAndType(
I.getOperand(0), InstID, Vals);
2948 case Instruction::CleanupRet: {
2950 const auto &CRI = cast<CleanupReturnInst>(
I);
2951 pushValue(CRI.getCleanupPad(), InstID, Vals);
2952 if (CRI.hasUnwindDest())
2953 Vals.push_back(VE.
getValueID(CRI.getUnwindDest()));
2956 case Instruction::CatchRet: {
2958 const auto &CRI = cast<CatchReturnInst>(
I);
2959 pushValue(CRI.getCatchPad(), InstID, Vals);
2960 Vals.push_back(VE.
getValueID(CRI.getSuccessor()));
2963 case Instruction::CleanupPad:
2964 case Instruction::CatchPad: {
2965 const auto &FuncletPad = cast<FuncletPadInst>(
I);
2968 pushValue(FuncletPad.getParentPad(), InstID, Vals);
2970 unsigned NumArgOperands = FuncletPad.getNumArgOperands();
2971 Vals.push_back(NumArgOperands);
2972 for (
unsigned Op = 0;
Op != NumArgOperands; ++
Op)
2973 pushValueAndType(FuncletPad.getArgOperand(
Op), InstID, Vals);
2976 case Instruction::CatchSwitch: {
2978 const auto &CatchSwitch = cast<CatchSwitchInst>(
I);
2980 pushValue(CatchSwitch.getParentPad(), InstID, Vals);
2982 unsigned NumHandlers = CatchSwitch.getNumHandlers();
2983 Vals.push_back(NumHandlers);
2984 for (
const BasicBlock *CatchPadBB : CatchSwitch.handlers())
2987 if (CatchSwitch.hasUnwindDest())
2988 Vals.push_back(VE.
getValueID(CatchSwitch.getUnwindDest()));
2991 case Instruction::CallBr: {
2997 writeOperandBundles(*CBI, InstID);
3012 pushValueAndType(Callee, InstID, Vals);
3016 pushValue(
I.getOperand(
i), InstID, Vals);
3021 pushValueAndType(
I.getOperand(
i), InstID, Vals);
3025 case Instruction::Unreachable:
3027 AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
3030 case Instruction::PHI: {
3031 const PHINode &PN = cast<PHINode>(
I);
3045 Vals64.push_back(Flags);
3048 Stream.EmitRecord(Code, Vals64, AbbrevToUse);
3053 case Instruction::LandingPad: {
3064 pushValueAndType(LP.
getClause(
I), InstID, Vals);
3069 case Instruction::Alloca: {
3073 Vals.push_back(VE.
getTypeID(
I.getOperand(0)->getType()));
3077 unsigned EncodedAlign = getEncodedAlign(AI.
getAlign());
3078 Bitfield::set<APV::AlignLower>(
3080 Bitfield::set<APV::AlignUpper>(
Record,
3083 Bitfield::set<APV::ExplicitType>(
Record,
true);
3088 if (AS !=
M.getDataLayout().getAllocaAddrSpace())
3094 if (cast<LoadInst>(
I).isAtomic()) {
3096 pushValueAndType(
I.getOperand(0), InstID, Vals);
3099 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
3100 AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
3103 Vals.push_back(getEncodedAlign(cast<LoadInst>(
I).
getAlign()));
3104 Vals.push_back(cast<LoadInst>(
I).isVolatile());
3105 if (cast<LoadInst>(
I).isAtomic()) {
3107 Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(
I).getSyncScopeID()));
3111 if (cast<StoreInst>(
I).isAtomic())
3115 pushValueAndType(
I.getOperand(1), InstID, Vals);
3116 pushValueAndType(
I.getOperand(0), InstID, Vals);
3117 Vals.push_back(getEncodedAlign(cast<StoreInst>(
I).
getAlign()));
3118 Vals.push_back(cast<StoreInst>(
I).isVolatile());
3119 if (cast<StoreInst>(
I).isAtomic()) {
3122 getEncodedSyncScopeID(cast<StoreInst>(
I).getSyncScopeID()));
3125 case Instruction::AtomicCmpXchg:
3127 pushValueAndType(
I.getOperand(0), InstID, Vals);
3128 pushValueAndType(
I.getOperand(1), InstID, Vals);
3129 pushValue(
I.getOperand(2), InstID, Vals);
3130 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isVolatile());
3134 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(
I).getSyncScopeID()));
3137 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isWeak());
3138 Vals.push_back(getEncodedAlign(cast<AtomicCmpXchgInst>(
I).
getAlign()));
3140 case Instruction::AtomicRMW:
3142 pushValueAndType(
I.getOperand(0), InstID, Vals);
3143 pushValueAndType(
I.getOperand(1), InstID, Vals);
3146 Vals.push_back(cast<AtomicRMWInst>(
I).isVolatile());
3149 getEncodedSyncScopeID(cast<AtomicRMWInst>(
I).getSyncScopeID()));
3150 Vals.push_back(getEncodedAlign(cast<AtomicRMWInst>(
I).
getAlign()));
3152 case Instruction::Fence:
3155 Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(
I).getSyncScopeID()));
3162 writeOperandBundles(CI, InstID);
3176 Vals.push_back(Flags);
3197 case Instruction::VAArg:
3199 Vals.push_back(VE.
getTypeID(
I.getOperand(0)->getType()));
3200 pushValue(
I.getOperand(0), InstID, Vals);
3203 case Instruction::Freeze:
3205 pushValueAndType(
I.getOperand(0), InstID, Vals);
3209 Stream.EmitRecord(Code, Vals, AbbrevToUse);
3215 void ModuleBitcodeWriter::writeGlobalValueSymbolTable(
3221 VSTOffset -= bitcodeStartBit();
3222 assert((VSTOffset & 31) == 0 &&
"VST block not 32-bit aligned");
3226 Stream.BackpatchWord(VSTOffsetPlaceholder, VSTOffset / 32 + 1);
3230 auto Abbv = std::make_shared<BitCodeAbbrev>();
3239 if (
F.isDeclaration())
3246 uint64_t BitcodeIndex = FunctionToBitcodeIndex[&
F] - bitcodeStartBit();
3247 assert((BitcodeIndex & 31) == 0 &&
"function block not 32-bit aligned");
3251 Record[1] = BitcodeIndex / 32 + 1;
3260 void ModuleBitcodeWriter::writeFunctionLevelValueSymbolTable(
3275 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
3281 if (isa<BasicBlock>(
Name.getValue())) {
3284 AbbrevToUse = VST_BBENTRY_6_ABBREV;
3288 AbbrevToUse = VST_ENTRY_6_ABBREV;
3290 AbbrevToUse = VST_ENTRY_7_ABBREV;
3293 for (
const auto P :
Name.getKey())
3294 NameVals.push_back((
unsigned char)
P);
3297 Stream.EmitRecord(Code, NameVals, AbbrevToUse);
3304 void ModuleBitcodeWriter::writeUseList(
UseListOrder &&Order) {
3305 assert(Order.Shuffle.size() >= 2 &&
"Shuffle too small");
3307 if (isa<BasicBlock>(Order.V))
3317 void ModuleBitcodeWriter::writeUseListBlock(
const Function *
F) {
3319 "Expected to be preserving use-list order");
3321 auto hasMore = [&]() {
3337 void ModuleBitcodeWriter::writeFunction(
3342 FunctionToBitcodeIndex[&
F] =
Stream.GetCurrentBitNo();
3356 unsigned CstStart, CstEnd;
3358 writeConstants(CstStart, CstEnd,
false);
3361 writeFunctionMetadata(
F);
3364 unsigned InstID = CstEnd;
3366 bool NeedsMetadataAttachment =
F.hasMetadata();
3374 writeInstruction(
I, InstID, Vals);
3376 if (!
I.getType()->isVoidTy())
3380 NeedsMetadataAttachment |=
I.hasMetadataOtherThanDebugLoc();
3393 Vals.push_back(
DL->getLine());
3394 Vals.push_back(
DL->getColumn());
3397 Vals.push_back(
DL->isImplicitCode());
3407 while (!Worklist.empty()) {
3408 Value *V = Worklist.pop_back_val();
3410 if (
auto *
I = dyn_cast<Instruction>(U)) {
3414 }
else if (isa<Constant>(U) && !isa<GlobalValue>(U) &&
3415 Visited.insert(U).second)
3416 Worklist.push_back(U);
3422 if (!BlockAddressUsers.
empty()) {
3431 if (
auto *Symtab =
F.getValueSymbolTable())
3432 writeFunctionLevelValueSymbolTable(*Symtab);
3434 if (NeedsMetadataAttachment)
3435 writeFunctionMetadataAttachment(
F);
3437 writeUseListBlock(&
F);
3443 void ModuleBitcodeWriter::writeBlockInfo() {
3447 Stream.EnterBlockInfoBlock();
3450 auto Abbv = std::make_shared<BitCodeAbbrev>();
3461 auto Abbv = std::make_shared<BitCodeAbbrev>();
3471 auto Abbv = std::make_shared<BitCodeAbbrev>();
3481 auto Abbv = std::make_shared<BitCodeAbbrev>();
3487 VST_BBENTRY_6_ABBREV)
3492 auto Abbv = std::make_shared<BitCodeAbbrev>();
3497 CONSTANTS_SETTYPE_ABBREV)
3502 auto Abbv = std::make_shared<BitCodeAbbrev>();
3506 CONSTANTS_INTEGER_ABBREV)
3511 auto Abbv = std::make_shared<BitCodeAbbrev>();
3519 CONSTANTS_CE_CAST_Abbrev)
3523 auto Abbv = std::make_shared<BitCodeAbbrev>();
3526 CONSTANTS_NULL_Abbrev)
3533 auto Abbv = std::make_shared<BitCodeAbbrev>();
3541 FUNCTION_INST_LOAD_ABBREV)
3545 auto Abbv = std::make_shared<BitCodeAbbrev>();
3550 FUNCTION_INST_UNOP_ABBREV)
3554 auto Abbv = std::make_shared<BitCodeAbbrev>();
3560 FUNCTION_INST_UNOP_FLAGS_ABBREV)
3564 auto Abbv = std::make_shared<BitCodeAbbrev>();
3570 FUNCTION_INST_BINOP_ABBREV)
3574 auto Abbv = std::make_shared<BitCodeAbbrev>();
3581 FUNCTION_INST_BINOP_FLAGS_ABBREV)
3585 auto Abbv = std::make_shared<BitCodeAbbrev>();
3592 FUNCTION_INST_CAST_ABBREV)
3597 auto Abbv = std::make_shared<BitCodeAbbrev>();
3600 FUNCTION_INST_RET_VOID_ABBREV)
3604 auto Abbv = std::make_shared<BitCodeAbbrev>();
3608 FUNCTION_INST_RET_VAL_ABBREV)
3612 auto Abbv = std::make_shared<BitCodeAbbrev>();
3615 FUNCTION_INST_UNREACHABLE_ABBREV)
3619 auto Abbv = std::make_shared<BitCodeAbbrev>();
3627 FUNCTION_INST_GEP_ABBREV)
3636 void IndexBitcodeWriter::writeModStrings() {
3642 auto Abbv = std::make_shared<BitCodeAbbrev>();
3650 Abbv = std::make_shared<BitCodeAbbrev>();
3658 Abbv = std::make_shared<BitCodeAbbrev>();
3666 Abbv = std::make_shared<BitCodeAbbrev>();
3677 [&](
const StringMapEntry<std::pair<uint64_t, ModuleHash>> &MPSE) {
3679 const auto &
Value = MPSE.getValue();
3681 unsigned AbbrevToUse = Abbrev8Bit;
3683 AbbrevToUse = Abbrev6Bit;
3685 AbbrevToUse = Abbrev7Bit;
3687 Vals.push_back(
Value.first);
3694 const auto &Hash =
Value.second;
3696 Vals.
assign(Hash.begin(), Hash.end());
3708 template <
typename Fn>
3712 if (!
FS->type_tests().empty())
3717 auto WriteVFuncIdVec = [&](
uint64_t Ty,
3722 for (
auto &VF : VFs) {
3723 Record.push_back(VF.GUID);
3724 Record.push_back(VF.Offset);
3726 Stream.EmitRecord(Ty,
Record);
3730 FS->type_test_assume_vcalls());
3732 FS->type_checked_load_vcalls());
3734 auto WriteConstVCallVec = [&](
uint64_t Ty,
3736 for (
auto &
VC : VCs) {
3741 Stream.EmitRecord(Ty,
Record);
3746 FS->type_test_assume_const_vcalls());
3748 FS->type_checked_load_const_vcalls());
3752 assert(Range.getLower().getNumWords() == 1);
3753 assert(Range.getUpper().getNumWords() == 1);
3758 if (!
FS->paramAccesses().empty()) {
3760 for (
auto &
Arg :
FS->paramAccesses()) {
3761 size_t UndoSize =
Record.size();
3763 WriteRange(
Arg.Use);
3765 for (
auto &Call :
Arg.Calls) {
3766 Record.push_back(Call.ParamNo);
3774 Record.push_back(*ValueID);
3775 WriteRange(Call.Offsets);
3786 std::set<GlobalValue::GUID> &ReferencedTypeIds) {
3787 if (!
FS->type_tests().empty())
3788 for (
auto &TT :
FS->type_tests())
3789 ReferencedTypeIds.insert(TT);
3791 auto GetReferencedTypesFromVFuncIdVec =
3793 for (
auto &VF : VFs)
3794 ReferencedTypeIds.insert(VF.GUID);
3797 GetReferencedTypesFromVFuncIdVec(
FS->type_test_assume_vcalls());
3798 GetReferencedTypesFromVFuncIdVec(
FS->type_checked_load_vcalls());
3800 auto GetReferencedTypesFromConstVCallVec =
3802 for (
auto &
VC : VCs)
3803 ReferencedTypeIds.insert(
VC.VFunc.GUID);
3806 GetReferencedTypesFromConstVCallVec(
FS->type_test_assume_const_vcalls());
3807 GetReferencedTypesFromConstVCallVec(
FS->type_checked_load_const_vcalls());
3813 NameVals.push_back(args.size());
3816 NameVals.push_back(ByArg.
TheKind);
3817 NameVals.push_back(ByArg.
Info);
3818 NameVals.push_back(ByArg.
Byte);
3819 NameVals.push_back(ByArg.
Bit);
3825 NameVals.push_back(
Id);
3827 NameVals.push_back(Wpd.
TheKind);
3831 NameVals.push_back(Wpd.
ResByArg.size());
3838 const std::string &
Id,
3840 NameVals.push_back(StrtabBuilder.
add(
Id));
3841 NameVals.push_back(
Id.size());
3850 for (
auto &
W : Summary.
WPDRes)
3859 NameVals.push_back(StrtabBuilder.
add(
Id));
3860 NameVals.push_back(
Id.size());
3862 for (
auto &
P : Summary) {
3863 NameVals.push_back(
P.AddressPointOffset);
3864 NameVals.push_back(VE.
getValueID(
P.VTableVI.getValue()));
3869 void ModuleBitcodeWriterBase::writePerModuleFunctionSummaryRecord(
3871 unsigned ValueID,
unsigned FSCallsAbbrev,
unsigned FSCallsProfileAbbrev,
3873 NameVals.push_back(ValueID);
3882 auto SpecialRefCnts =
FS->specialRefCounts();
3884 NameVals.push_back(
FS->instCount());
3886 NameVals.push_back(
FS->refs().size());
3887 NameVals.push_back(SpecialRefCnts.first);
3888 NameVals.push_back(SpecialRefCnts.second);
3890 for (
auto &RI :
FS->refs())
3891 NameVals.push_back(VE.
getValueID(RI.getValue()));
3893 bool HasProfileData =
3895 for (
auto &ECI :
FS->calls()) {
3896 NameVals.push_back(getValueId(ECI.first));
3898 NameVals.push_back(
static_cast<uint8_t
>(ECI.second.Hotness));
3900 NameVals.push_back(ECI.second.RelBlockFreq);
3903 unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
3910 Stream.EmitRecord(Code, NameVals, FSAbbrev);
3916 void ModuleBitcodeWriterBase::writeModuleLevelReferences(
3918 unsigned FSModRefsAbbrev,
unsigned FSModVTableRefsAbbrev) {
3920 if (!
VI ||
VI.getSummaryList().empty()) {
3926 auto *Summary =
VI.getSummaryList()[0].get();
3932 auto VTableFuncs =
VS->vTableFuncs();
3933 if (!VTableFuncs.empty())
3934 NameVals.push_back(
VS->refs().size());
3936 unsigned SizeBeforeRefs = NameVals.size();
3937 for (
auto &RI :
VS->refs())
3938 NameVals.push_back(VE.
getValueID(RI.getValue()));
3943 if (VTableFuncs.empty())
3948 for (
auto &
P : VTableFuncs) {
3949 NameVals.push_back(VE.
getValueID(
P.FuncVI.getValue()));
3950 NameVals.push_back(
P.VTableOffset);
3954 FSModVTableRefsAbbrev);
3961 void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
3964 bool IsThinLTO =
true;
3966 mdconst::extract_or_null<ConstantInt>(
M.getModuleFlag(
"ThinLTO")))
3967 IsThinLTO = MD->getZExtValue();
3979 if (
Index->enableSplitLTOUnit())
3988 for (
const auto &GVI : valueIds()) {
3994 auto Abbv = std::make_shared<BitCodeAbbrev>();
4009 Abbv = std::make_shared<BitCodeAbbrev>();
4027 Abbv = std::make_shared<BitCodeAbbrev>();
4036 Abbv = std::make_shared<BitCodeAbbrev>();
4047 Abbv = std::make_shared<BitCodeAbbrev>();
4055 Abbv = std::make_shared<BitCodeAbbrev>();
4062 unsigned TypeIdCompatibleVtableAbbrev =
Stream.EmitAbbrev(
std::move(Abbv));
4074 if (!
VI ||
VI.getSummaryList().empty()) {
4080 auto *Summary =
VI.getSummaryList()[0].get();
4081 writePerModuleFunctionSummaryRecord(NameVals, Summary, VE.
getValueID(&
F),
4082 FSCallsAbbrev, FSCallsProfileAbbrev,
F);
4088 writeModuleLevelReferences(
G, NameVals, FSModRefsAbbrev,
4089 FSModVTableRefsAbbrev);
4092 auto *Aliasee =
A.getAliaseeObject();
4093 if (!Aliasee->hasName())
4098 NameVals.push_back(AliasId);
4099 auto *Summary =
Index->getGlobalValueSummary(A);
4102 NameVals.push_back(AliaseeId);
4107 for (
auto &
S :
Index->typeIdCompatibleVtableMap()) {
4111 TypeIdCompatibleVtableAbbrev);
4122 void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
4131 for (
const auto &GVI : valueIds()) {
4137 auto Abbv = std::make_shared<BitCodeAbbrev>();
4154 Abbv = std::make_shared<BitCodeAbbrev>();
4171 Abbv = std::make_shared<BitCodeAbbrev>();
4181 Abbv = std::make_shared<BitCodeAbbrev>();
4200 std::set<GlobalValue::GUID> ReferencedTypeIds;
4214 NameVals.push_back(
S.getOriginalName());
4219 std::set<GlobalValue::GUID> DefOrUseGUIDs;
4220 forEachSummary([&](GVInfo
I,
bool IsAliasee) {
4223 DefOrUseGUIDs.insert(
I.first);
4225 DefOrUseGUIDs.insert(
VI.getGUID());
4227 auto ValueId = getValueId(
I.first);
4229 SummaryToValueIdMap[
S] = *ValueId;
4237 if (
auto *AS = dyn_cast<AliasSummary>(
S)) {
4240 Aliases.push_back(AS);
4244 if (
auto *
VS = dyn_cast<GlobalVarSummary>(
S)) {
4245 NameVals.push_back(*ValueId);
4246 NameVals.push_back(
Index.getModuleId(
VS->modulePath()));
4249 for (
auto &RI :
VS->refs()) {
4250 auto RefValueId = getValueId(RI.getGUID());
4253 NameVals.push_back(*RefValueId);
4260 MaybeEmitOriginalName(*
S);
4265 return getValueId(
VI.getGUID());
4268 auto *
FS = cast<FunctionSummary>(
S);
4272 NameVals.push_back(*ValueId);
4273 NameVals.push_back(
Index.getModuleId(
FS->modulePath()));
4275 NameVals.push_back(
FS->instCount());
4277 NameVals.push_back(
FS->entryCount());
4280 NameVals.push_back(0);
4281 NameVals.push_back(0);
4282 NameVals.push_back(0);
4284 unsigned Count = 0, RORefCnt = 0, WORefCnt = 0;
4285 for (
auto &RI :
FS->refs()) {
4286 auto RefValueId = getValueId(RI.getGUID());
4289 NameVals.push_back(*RefValueId);
4290 if (RI.isReadOnly())
4292 else if (RI.isWriteOnly())
4296 NameVals[6] = Count;
4297 NameVals[7] = RORefCnt;
4298 NameVals[8] = WORefCnt;
4300 bool HasProfileData =
false;
4301 for (
auto &EI :
FS->calls()) {
4308 for (
auto &EI :
FS->calls()) {
4314 NameVals.push_back(*CallValueId);
4316 NameVals.push_back(
static_cast<uint8_t
>(EI.second.Hotness));
4319 unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
4324 Stream.EmitRecord(Code, NameVals, FSAbbrev);
4326 MaybeEmitOriginalName(*
S);
4329 for (
auto *AS : Aliases) {
4330 auto AliasValueId = SummaryToValueIdMap[AS];
4332 NameVals.push_back(AliasValueId);
4335 auto AliaseeValueId = SummaryToValueIdMap[&AS->
getAliasee()];
4337 NameVals.push_back(AliaseeValueId);
4342 MaybeEmitOriginalName(*AS);
4344 if (
auto *
FS = dyn_cast<FunctionSummary>(&AS->
getAliasee()))
4348 if (!
Index.cfiFunctionDefs().empty()) {
4349 for (
auto &
S :
Index.cfiFunctionDefs()) {
4350 if (DefOrUseGUIDs.count(
4352 NameVals.push_back(StrtabBuilder.
add(
S));
4353 NameVals.push_back(
S.size());
4356 if (!NameVals.empty()) {
4362 if (!
Index.cfiFunctionDecls().empty()) {
4363 for (
auto &
S :
Index.cfiFunctionDecls()) {
4364 if (DefOrUseGUIDs.count(
4366 NameVals.push_back(StrtabBuilder.
add(
S));
4367 NameVals.push_back(
S.size());
4370 if (!NameVals.empty()) {
4378 for (
auto &
T : ReferencedTypeIds) {
4379 auto TidIter =
Index.typeIds().equal_range(
T);
4380 for (
auto It = TidIter.first; It != TidIter.second; ++It) {
4400 auto Abbv = std::make_shared<BitCodeAbbrev>();
4404 auto StringAbbrev = Stream.EmitAbbrev(
std::move(Abbv));
4406 "LLVM" LLVM_VERSION_STRING, StringAbbrev);
4409 Abbv = std::make_shared<BitCodeAbbrev>();
4412 auto EpochAbbrev = Stream.EmitAbbrev(
std::move(Abbv));
4418 void ModuleBitcodeWriter::writeModuleHash(
size_t BlockStartPos) {
4424 Buffer.size() - BlockStartPos));
4425 std::array<uint8_t, 20> Hash = Hasher.result();
4426 for (
int Pos = 0; Pos < 20; Pos += 4) {
4443 size_t BlockStartPos = Buffer.size();
4445 writeModuleVersion();
4454 writeAttributeGroupTable();
4457 writeAttributeTable();
4466 writeModuleConstants();
4469 writeModuleMetadataKinds();
4472 writeModuleMetadata();
4476 writeUseListBlock(
nullptr);
4478 writeOperandBundleTags();
4479 writeSyncScopeNames();
4484 if (!
F.isDeclaration())
4485 writeFunction(
F, FunctionToBitcodeIndex);
4490 writePerModuleGlobalValueSummary();
4492 writeGlobalValueSymbolTable(FunctionToBitcodeIndex);
4494 writeModuleHash(BlockStartPos);
4527 DARWIN_CPU_ARCH_ABI64 = 0x01000000,
4528 DARWIN_CPU_TYPE_X86 = 7,
4529 DARWIN_CPU_TYPE_ARM = 12,
4530 DARWIN_CPU_TYPE_POWERPC = 18
4535 CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64;
4537 CPUType = DARWIN_CPU_TYPE_X86;
4539 CPUType = DARWIN_CPU_TYPE_POWERPC;
4541 CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;
4543 CPUType = DARWIN_CPU_TYPE_ARM;
4547 "Expected header size to be reserved");
4552 unsigned Position = 0;
4560 while (Buffer.size() & 15)
4561 Buffer.push_back(0);
4567 Stream.Emit((
unsigned)
'B', 8);
4568 Stream.Emit((
unsigned)
'C', 8);
4569 Stream.Emit(0x0, 4);
4570 Stream.Emit(0xC, 4);
4571 Stream.Emit(0xE, 4);
4572 Stream.Emit(0xD, 4);
4582 void BitcodeWriter::writeBlob(
unsigned Block,
unsigned Record,
StringRef Blob) {
4583 Stream->EnterSubblock(Block, 3);
4585 auto Abbv = std::make_shared<BitCodeAbbrev>();
4588 auto AbbrevNo = Stream->EmitAbbrev(
std::move(Abbv));
4592 Stream->ExitBlock();
4596 assert(!WroteStrtab && !WroteSymtab);
4602 if (
M->getModuleInlineAsm().empty())
4606 const Triple TT(
M->getTargetTriple());
4608 if (!
T || !
T->hasMCAsmParser())
4624 {Symtab.data(), Symtab.size()});
4630 std::vector<char> Strtab;
4632 Strtab.resize(StrtabBuilder.
getSize());
4633 StrtabBuilder.
write((uint8_t *)Strtab.data());
4636 {Strtab.data(), Strtab.size()});
4647 bool ShouldPreserveUseListOrder,
4657 Mods.push_back(
const_cast<Module *
>(&
M));
4659 ModuleBitcodeWriter ModuleWriter(
M, Buffer, StrtabBuilder, *Stream,
4660 ShouldPreserveUseListOrder, Index,
4661 GenerateHash, ModHash);
4662 ModuleWriter.write();
4667 const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
4668 IndexBitcodeWriter IndexWriter(*Stream, StrtabBuilder, *Index,
4669 ModuleToSummariesForIndex);
4670 IndexWriter.write();
4675 bool ShouldPreserveUseListOrder,
4683 Triple TT(
M.getTargetTriple());
4684 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())