58 #define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
59 #include "llvm/IR/Metadata.def"
77 CONSTANTS_INTEGER_ABBREV,
78 CONSTANTS_CE_CAST_Abbrev,
79 CONSTANTS_NULL_Abbrev,
83 FUNCTION_INST_BINOP_ABBREV,
84 FUNCTION_INST_BINOP_FLAGS_ABBREV,
85 FUNCTION_INST_CAST_ABBREV,
86 FUNCTION_INST_RET_VOID_ABBREV,
87 FUNCTION_INST_RET_VAL_ABBREV,
88 FUNCTION_INST_UNREACHABLE_ABBREV,
89 FUNCTION_INST_GEP_ABBREV,
110 std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
113 unsigned GlobalValueId;
133 : I8Ty(
Type::getInt8Ty(
M.getContext())),
135 StrtabBuilder(StrtabBuilder),
M(
M), VE(
M, I8PtrTy), Buffer(Buffer),
136 BitcodeStartBit(Stream.GetCurrentBitNo()),
137 PointerMap(PointerTypeAnalysis::
run(
M)) {
140 for (
auto El : PointerMap)
168 void writeModuleVersion();
169 void writePerModuleGlobalValueSummary();
174 unsigned FSCallsAbbrev,
175 unsigned FSCallsProfileAbbrev,
179 unsigned FSModRefsAbbrev,
180 unsigned FSModVTableRefsAbbrev);
183 GUIDToValueIdMap[ValGUID] = ++GlobalValueId;
187 const auto &VMI = GUIDToValueIdMap.find(ValGUID);
190 assert(VMI != GUIDToValueIdMap.end() &&
191 "GUID does not have assigned value Id");
197 if (!
VI.haveGVs() || !
VI.getValue())
198 return getValueId(
VI.getGUID());
202 std::map<GlobalValue::GUID, unsigned> &valueIds() {
return GUIDToValueIdMap; }
204 uint64_t bitcodeStartBit() {
return BitcodeStartBit; }
208 unsigned createDILocationAbbrev();
209 unsigned createGenericDINodeAbbrev();
211 void writeAttributeGroupTable();
212 void writeAttributeTable();
213 void writeTypeTable();
215 void writeValueSymbolTableForwardDecl();
216 void writeModuleInfo();
307 unsigned createNamedMetadataAbbrev();
309 unsigned createMetadataStringsAbbrev();
314 std::vector<unsigned> *MDAbbrevs =
nullptr,
315 std::vector<uint64_t> *IndexPos =
nullptr);
316 void writeModuleMetadata();
317 void writeFunctionMetadata(
const Function &
F);
318 void writeFunctionMetadataAttachment(
const Function &
F);
321 void writeModuleMetadataKinds();
322 void writeOperandBundleTags();
323 void writeSyncScopeNames();
324 void writeConstants(
unsigned FirstVal,
unsigned LastVal,
bool isGlobal);
325 void writeModuleConstants();
326 bool pushValueAndType(
const Value *V,
unsigned InstID,
328 void writeOperandBundles(
const CallBase &CB,
unsigned InstID);
329 void pushValue(
const Value *V,
unsigned InstID,
331 void pushValueSigned(
const Value *V,
unsigned InstID,
333 void writeInstruction(
const Instruction &
I,
unsigned InstID,
336 void writeGlobalValueSymbolTable(
339 void writeUseListBlock(
const Function *
F);
341 void writeBlockInfo();
343 unsigned getEncodedSyncScopeID(
SyncScope::ID SSID) {
return unsigned(SSID); }
345 unsigned getEncodedAlign(
MaybeAlign Alignment) {
return encode(Alignment); }
347 unsigned getTypeID(
Type *
T,
const Value *V =
nullptr);
354 using namespace llvm;
365 Stream->Emit((
unsigned)
'B', 8);
366 Stream->Emit((
unsigned)
'C', 8);
367 Stream->Emit(0x0, 4);
368 Stream->Emit(0xC, 4);
369 Stream->Emit(0xE, 4);
370 Stream->Emit(0xD, 4);
382 Triple TT(
M.getTargetTriple());
383 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
393 Out.
write((
char *)&Buffer.front(), Buffer.size());
396 void BitcodeWriter::writeBlob(
unsigned Block,
unsigned Record,
StringRef Blob) {
397 Stream->EnterSubblock(Block, 3);
399 auto Abbv = std::make_shared<BitCodeAbbrev>();
402 auto AbbrevNo = Stream->EmitAbbrev(
std::move(Abbv));
410 assert(!WroteStrtab && !WroteSymtab);
416 if (
M->getModuleInlineAsm().empty())
432 {Symtab.data(), Symtab.size()});
438 std::vector<char> Strtab;
440 Strtab.resize(StrtabBuilder.
getSize());
441 StrtabBuilder.
write((uint8_t *)Strtab.data());
444 {Strtab.data(), Strtab.size()});
462 Mods.push_back(
const_cast<Module *
>(&
M));
465 ModuleWriter.
write();
476 case Instruction::Trunc:
478 case Instruction::ZExt:
480 case Instruction::SExt:
482 case Instruction::FPToUI:
484 case Instruction::FPToSI:
486 case Instruction::UIToFP:
488 case Instruction::SIToFP:
490 case Instruction::FPTrunc:
492 case Instruction::FPExt:
494 case Instruction::PtrToInt:
496 case Instruction::IntToPtr:
498 case Instruction::BitCast:
500 case Instruction::AddrSpaceCast:
509 case Instruction::FNeg:
519 case Instruction::FAdd:
521 case Instruction::Sub:
522 case Instruction::FSub:
525 case Instruction::FMul:
527 case Instruction::UDiv:
529 case Instruction::FDiv:
530 case Instruction::SDiv:
532 case Instruction::URem:
534 case Instruction::FRem:
535 case Instruction::SRem:
537 case Instruction::Shl:
539 case Instruction::LShr:
541 case Instruction::AShr:
543 case Instruction::And:
545 case Instruction::Or:
547 case Instruction::Xor:
552 unsigned DXILBitcodeWriter::getTypeID(
Type *
T,
const Value *V) {
553 if (!
T->isOpaquePointerTy())
555 auto It = PointerMap.
find(V);
556 if (It != PointerMap.
end())
561 unsigned DXILBitcodeWriter::getTypeID(
Type *
T,
const Function *
F) {
562 auto It = PointerMap.
find(
F);
563 if (It != PointerMap.
end())
623 unsigned AbbrevToUse) {
634 Stream.EmitRecord(Code, Vals, AbbrevToUse);
639 case Attribute::Alignment:
641 case Attribute::AlwaysInline:
643 case Attribute::ArgMemOnly:
645 case Attribute::Builtin:
647 case Attribute::ByVal:
651 case Attribute::InAlloca:
655 case Attribute::InlineHint:
657 case Attribute::InReg:
661 case Attribute::MinSize:
663 case Attribute::Naked:
665 case Attribute::Nest:
667 case Attribute::NoAlias:
669 case Attribute::NoBuiltin:
671 case Attribute::NoCapture:
673 case Attribute::NoDuplicate:
675 case Attribute::NoImplicitFloat:
677 case Attribute::NoInline:
679 case Attribute::NonLazyBind:
681 case Attribute::NonNull:
683 case Attribute::Dereferenceable:
685 case Attribute::DereferenceableOrNull:
687 case Attribute::NoRedZone:
689 case Attribute::NoReturn:
691 case Attribute::NoUnwind:
693 case Attribute::OptimizeForSize:
695 case Attribute::OptimizeNone:
697 case Attribute::ReadNone:
699 case Attribute::ReadOnly:
701 case Attribute::Returned:
703 case Attribute::ReturnsTwice:
705 case Attribute::SExt:
707 case Attribute::StackAlignment:
709 case Attribute::StackProtect:
711 case Attribute::StackProtectReq:
713 case Attribute::StackProtectStrong:
715 case Attribute::SafeStack:
717 case Attribute::StructRet:
719 case Attribute::SanitizeAddress:
721 case Attribute::SanitizeThread:
723 case Attribute::SanitizeMemory:
725 case Attribute::UWTable:
727 case Attribute::ZExt:
738 "should be stripped in DXILPrepare");
747 Vals.push_back(V << 1);
749 Vals.push_back((-V << 1) | 1);
758 unsigned NumWords = A.getActiveWords();
759 const uint64_t *RawData = A.getRawData();
760 for (
unsigned i = 0;
i < NumWords;
i++)
767 if (
const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
768 if (OBO->hasNoSignedWrap())
770 if (OBO->hasNoUnsignedWrap())
772 }
else if (
const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
775 }
else if (
const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
776 if (FPMO->hasAllowReassoc())
778 if (FPMO->hasNoNaNs())
780 if (FPMO->hasNoInfs())
782 if (FPMO->hasNoSignedZeros())
784 if (FPMO->hasAllowReciprocal())
786 if (FPMO->hasAllowContract())
788 if (FPMO->hasApproxFunc())
869 switch (
C.getSelectionKind()) {
888 void DXILBitcodeWriter::writeAttributeGroupTable() {
889 const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
891 if (AttrGrps.empty())
898 unsigned AttrListIndex = Pair.first;
901 Record.push_back(AttrListIndex);
904 if (Attr.isEnumAttribute()) {
907 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
910 }
else if (Attr.isIntAttribute()) {
913 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
916 Record.push_back(Attr.getValueAsInt());
938 void DXILBitcodeWriter::writeAttributeTable() {
948 for (
unsigned i :
AL.indexes()) {
962 void DXILBitcodeWriter::writeTypeTable() {
971 auto Abbv = std::make_shared<BitCodeAbbrev>();
978 Abbv = std::make_shared<BitCodeAbbrev>();
986 Abbv = std::make_shared<BitCodeAbbrev>();
994 Abbv = std::make_shared<BitCodeAbbrev>();
1001 Abbv = std::make_shared<BitCodeAbbrev>();
1009 Abbv = std::make_shared<BitCodeAbbrev>();
1016 TypeVals.push_back(TypeList.size());
1021 for (
Type *
T : TypeList) {
1022 int AbbrevToUse = 0;
1025 switch (
T->getTypeID()) {
1064 TypeVals.push_back(cast<IntegerType>(
T)->
getBitWidth());
1074 AbbrevToUse = PtrAbbrev;
1085 TypeVals.push_back(
false);
1088 "dxilOpaquePtrReservedName", StructNameAbbrev);
1094 AbbrevToUse = PtrAbbrev;
1102 TypeVals.push_back(FT->
isVarArg());
1105 TypeVals.push_back(getTypeID(PTy));
1106 AbbrevToUse = FunctionAbbrev;
1112 TypeVals.push_back(
ST->isPacked());
1114 for (
Type *ElTy :
ST->elements())
1115 TypeVals.push_back(getTypeID(ElTy));
1117 if (
ST->isLiteral()) {
1119 AbbrevToUse = StructAnonAbbrev;
1121 if (
ST->isOpaque()) {
1125 AbbrevToUse = StructNamedAbbrev;
1129 if (!
ST->getName().empty())
1141 AbbrevToUse = ArrayAbbrev;
1156 Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
1163 void DXILBitcodeWriter::writeComdats() {
1168 size_t Size =
C->getName().size();
1170 Vals.push_back(Size);
1171 for (
char Chr :
C->getName())
1172 Vals.push_back((
unsigned char)Chr);
1178 void DXILBitcodeWriter::writeValueSymbolTableForwardDecl() {}
1183 void DXILBitcodeWriter::writeModuleInfo() {
1185 if (!
M.getTargetTriple().empty())
1188 const std::string &
DL =
M.getDataLayoutStr();
1191 if (!
M.getModuleInlineAsm().empty())
1197 std::map<std::string, unsigned> SectionMap;
1198 std::map<std::string, unsigned> GCMap;
1200 unsigned MaxGlobalType = 0;
1201 const auto UpdateMaxAlignment = [&MaxAlignment](
const MaybeAlign A) {
1203 MaxAlignment = !MaxAlignment ? *
A :
std::max(*MaxAlignment, *A);
1206 UpdateMaxAlignment(GV.getAlign());
1207 MaxGlobalType =
std::max(MaxGlobalType, getTypeID(GV.getValueType(), &GV));
1208 if (GV.hasSection()) {
1210 unsigned &Entry = SectionMap[std::string(GV.getSection())];
1213 GV.getSection(), 0 );
1214 Entry = SectionMap.size();
1219 UpdateMaxAlignment(
F.getAlign());
1220 if (
F.hasSection()) {
1222 unsigned &Entry = SectionMap[std::string(
F.getSection())];
1226 Entry = SectionMap.size();
1231 unsigned &Entry = GCMap[
F.getGC()];
1235 Entry = GCMap.size();
1241 unsigned SimpleGVarAbbrev = 0;
1242 if (!
M.global_empty()) {
1245 auto Abbv = std::make_shared<BitCodeAbbrev>();
1257 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1261 if (SectionMap.empty())
1273 unsigned AbbrevToUse = 0;
1279 Vals.push_back(getTypeID(GV.getValueType(), &GV));
1281 GV.getType()->getAddressSpace() << 2 | 2 |
1282 (GV.isConstant() ? 1 : 0));
1285 GV.isDeclaration() ? 0 : (VE.
getValueID(GV.getInitializer()) + 1));
1287 Vals.push_back(getEncodedAlign(GV.getAlign()));
1288 Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1290 if (GV.isThreadLocal() ||
1293 GV.isExternallyInitialized() ||
1299 Vals.push_back(GV.isExternallyInitialized());
1301 Vals.push_back(GV.hasComdat() ? VE.
getComdatID(GV.getComdat()) : 0);
1303 AbbrevToUse = SimpleGVarAbbrev;
1315 Vals.push_back(getTypeID(
F.getFunctionType(), &
F));
1316 Vals.push_back(
F.getCallingConv());
1317 Vals.push_back(
F.isDeclaration());
1320 Vals.push_back(getEncodedAlign(
F.getAlign()));
1321 Vals.push_back(
F.hasSection() ? SectionMap[std::string(
F.getSection())]
1324 Vals.push_back(
F.hasGC() ? GCMap[
F.getGC()] : 0);
1327 F.hasPrologueData() ? (VE.
getValueID(
F.getPrologueData()) + 1) : 0);
1329 Vals.push_back(
F.hasComdat() ? VE.
getComdatID(
F.getComdat()) : 0);
1330 Vals.push_back(
F.hasPrefixData() ? (VE.
getValueID(
F.getPrefixData()) + 1)
1333 F.hasPersonalityFn() ? (VE.
getValueID(
F.getPersonalityFn()) + 1) : 0);
1335 unsigned AbbrevToUse = 0;
1343 Vals.push_back(getTypeID(
A.getValueType(), &A));
1350 unsigned AbbrevToUse = 0;
1356 void DXILBitcodeWriter::writeValueAsMetadata(
1361 if (
Function *
F = dyn_cast<Function>(V))
1365 Record.push_back(getTypeID(Ty));
1371 void DXILBitcodeWriter::writeMDTuple(
const MDTuple *
N,
1374 for (
unsigned i = 0,
e =
N->getNumOperands();
i !=
e; ++
i) {
1376 assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1377 "Unexpected function-local metadata");
1386 void DXILBitcodeWriter::writeDILocation(
const DILocation *
N,
1390 Abbrev = createDILocationAbbrev();
1391 Record.push_back(
N->isDistinct());
1392 Record.push_back(
N->getLine());
1393 Record.push_back(
N->getColumn());
1404 return I < 0 ? ~(U << 1) : U << 1;
1411 void DXILBitcodeWriter::writeDISubrange(
const DISubrange *
N,
1414 Record.push_back(
N->isDistinct());
1423 void DXILBitcodeWriter::writeDIEnumerator(
const DIEnumerator *
N,
1426 Record.push_back(
N->isDistinct());
1434 void DXILBitcodeWriter::writeDIBasicType(
const DIBasicType *
N,
1437 Record.push_back(
N->isDistinct());
1438 Record.push_back(
N->getTag());
1440 Record.push_back(
N->getSizeInBits());
1441 Record.push_back(
N->getAlignInBits());
1442 Record.push_back(
N->getEncoding());
1448 void DXILBitcodeWriter::writeDIDerivedType(
const DIDerivedType *
N,
1451 Record.push_back(
N->isDistinct());
1452 Record.push_back(
N->getTag());
1455 Record.push_back(
N->getLine());
1458 Record.push_back(
N->getSizeInBits());
1459 Record.push_back(
N->getAlignInBits());
1460 Record.push_back(
N->getOffsetInBits());
1461 Record.push_back(
N->getFlags());
1471 Record.push_back(
N->isDistinct());
1472 Record.push_back(
N->getTag());
1475 Record.push_back(
N->getLine());
1478 Record.push_back(
N->getSizeInBits());
1479 Record.push_back(
N->getAlignInBits());
1480 Record.push_back(
N->getOffsetInBits());
1481 Record.push_back(
N->getFlags());
1483 Record.push_back(
N->getRuntimeLang());
1495 Record.push_back(
N->isDistinct());
1496 Record.push_back(
N->getFlags());
1503 void DXILBitcodeWriter::writeDIFile(
const DIFile *
N,
1506 Record.push_back(
N->isDistinct());
1514 void DXILBitcodeWriter::writeDICompileUnit(
const DICompileUnit *
N,
1517 Record.push_back(
N->isDistinct());
1518 Record.push_back(
N->getSourceLanguage());
1521 Record.push_back(
N->isOptimized());
1523 Record.push_back(
N->getRuntimeVersion());
1525 Record.push_back(
N->getEmissionKind());
1531 Record.push_back(
N->getDWOId());
1537 void DXILBitcodeWriter::writeDISubprogram(
const DISubprogram *
N,
1540 Record.push_back(
N->isDistinct());
1545 Record.push_back(
N->getLine());
1547 Record.push_back(
N->isLocalToUnit());
1548 Record.push_back(
N->isDefinition());
1549 Record.push_back(
N->getScopeLine());
1551 Record.push_back(
N->getVirtuality());
1552 Record.push_back(
N->getVirtualIndex());
1553 Record.push_back(
N->getFlags());
1554 Record.push_back(
N->isOptimized());
1567 Record.push_back(
N->isDistinct());
1570 Record.push_back(
N->getLine());
1571 Record.push_back(
N->getColumn());
1577 void DXILBitcodeWriter::writeDILexicalBlockFile(
1580 Record.push_back(
N->isDistinct());
1583 Record.push_back(
N->getDiscriminator());
1589 void DXILBitcodeWriter::writeDINamespace(
const DINamespace *
N,
1592 Record.push_back(
N->isDistinct());
1602 void DXILBitcodeWriter::writeDIModule(
const DIModule *
N,
1605 Record.push_back(
N->isDistinct());
1606 for (
auto &
I :
N->operands())
1613 void DXILBitcodeWriter::writeDITemplateTypeParameter(
1616 Record.push_back(
N->isDistinct());
1624 void DXILBitcodeWriter::writeDITemplateValueParameter(
1627 Record.push_back(
N->isDistinct());
1628 Record.push_back(
N->getTag());
1640 Record.push_back(
N->isDistinct());
1645 Record.push_back(
N->getLine());
1647 Record.push_back(
N->isLocalToUnit());
1648 Record.push_back(
N->isDefinition());
1659 Record.push_back(
N->isDistinct());
1660 Record.push_back(
N->getTag());
1664 Record.push_back(
N->getLine());
1666 Record.push_back(
N->getArg());
1667 Record.push_back(
N->getFlags());
1673 void DXILBitcodeWriter::writeDIExpression(
const DIExpression *
N,
1676 Record.reserve(
N->getElements().size() + 1);
1678 Record.push_back(
N->isDistinct());
1679 Record.append(
N->elements_begin(),
N->elements_end());
1694 Record.push_back(
N->isDistinct());
1695 Record.push_back(
N->getTag());
1698 Record.push_back(
N->getLine());
1705 unsigned DXILBitcodeWriter::createDILocationAbbrev() {
1710 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1720 unsigned DXILBitcodeWriter::createGenericDINodeAbbrev() {
1725 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1738 std::vector<unsigned> *MDAbbrevs,
1739 std::vector<uint64_t> *IndexPos) {
1744 #define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
1745 #include "llvm/IR/Metadata.def"
1749 IndexPos->push_back(
Stream.GetCurrentBitNo());
1750 if (
const MDNode *
N = dyn_cast<MDNode>(MD)) {
1751 assert(
N->isResolved() &&
"Expected forward references to be resolved");
1753 switch (
N->getMetadataID()) {
1756 #define HANDLE_MDNODE_LEAF(CLASS) \
1757 case Metadata::CLASS##Kind: \
1759 write##CLASS(cast<CLASS>(N), Record, \
1760 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
1762 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
1764 #include "llvm/IR/Metadata.def"
1767 writeValueAsMetadata(cast<ValueAsMetadata>(MD),
Record);
1771 unsigned DXILBitcodeWriter::createMetadataStringsAbbrev() {
1772 auto Abbv = std::make_shared<BitCodeAbbrev>();
1779 void DXILBitcodeWriter::writeMetadataStrings(
1781 for (
const Metadata *MD : Strings) {
1782 const MDString *MDS = cast<MDString>(MD);
1788 createMetadataStringsAbbrev());
1793 void DXILBitcodeWriter::writeModuleMetadata() {
1794 if (!VE.
hasMDs() &&
M.named_metadata_empty())
1801 std::vector<unsigned> MDAbbrevs;
1804 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
1805 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
1806 createGenericDINodeAbbrev();
1808 unsigned NameAbbrev = 0;
1809 if (!
M.named_metadata_empty()) {
1811 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1821 std::vector<uint64_t> IndexPos;
1829 Record.append(Str.bytes_begin(), Str.bytes_end());
1834 for (
const MDNode *
N : NMD.operands())
1843 void DXILBitcodeWriter::writeFunctionMetadata(
const Function &
F) {
1854 void DXILBitcodeWriter::writeFunctionMetadataAttachment(
const Function &
F) {
1862 F.getAllMetadata(MDs);
1864 for (
const auto &
I : MDs) {
1875 I.getAllMetadataOtherThanDebugLoc(MDs);
1883 for (
unsigned i = 0,
e = MDs.size();
i !=
e; ++
i) {
1884 Record.push_back(MDs[
i].first);
1894 void DXILBitcodeWriter::writeModuleMetadataKinds() {
1900 M.getMDKindNames(Names);
1907 for (
unsigned MDKindID = 0,
e = Names.size(); MDKindID !=
e; ++MDKindID) {
1908 Record.push_back(MDKindID);
1919 void DXILBitcodeWriter::writeConstants(
unsigned FirstVal,
unsigned LastVal,
1921 if (FirstVal == LastVal)
1926 unsigned AggregateAbbrev = 0;
1927 unsigned String8Abbrev = 0;
1928 unsigned CString7Abbrev = 0;
1929 unsigned CString6Abbrev = 0;
1933 auto Abbv = std::make_shared<BitCodeAbbrev>();
1941 Abbv = std::make_shared<BitCodeAbbrev>();
1947 Abbv = std::make_shared<BitCodeAbbrev>();
1953 Abbv = std::make_shared<BitCodeAbbrev>();
1963 Type *LastTy =
nullptr;
1964 for (
unsigned i = FirstVal;
i != LastVal; ++
i) {
1965 const Value *V = Vals[
i].first;
1969 Record.push_back(getTypeID(LastTy));
1971 CONSTANTS_SETTYPE_ABBREV);
1975 if (
const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
1976 Record.push_back(
unsigned(IA->hasSideEffects()) |
1977 unsigned(IA->isAlignStack()) << 1 |
1978 unsigned(IA->getDialect() & 1) << 2);
1981 const std::string &AsmStr = IA->getAsmString();
1982 Record.push_back(AsmStr.size());
1983 Record.append(AsmStr.begin(), AsmStr.end());
1986 const std::string &ConstraintStr = IA->getConstraintString();
1987 Record.push_back(ConstraintStr.size());
1988 Record.append(ConstraintStr.begin(), ConstraintStr.end());
1994 unsigned Code = -1U;
1995 unsigned AbbrevToUse = 0;
1996 if (
C->isNullValue()) {
1998 }
else if (isa<UndefValue>(
C)) {
2001 if (
IV->getBitWidth() <= 64) {
2005 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2011 unsigned NWords =
IV->getValue().getActiveWords();
2012 const uint64_t *RawWords =
IV->getValue().getRawData();
2013 for (
unsigned i = 0;
i != NWords; ++
i) {
2018 }
else if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(
C)) {
2020 Type *Ty = CFP->getType();
2022 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2026 APInt api = CFP->getValueAPF().bitcastToAPInt();
2028 Record.push_back((
p[1] << 48) | (
p[0] >> 16));
2029 Record.push_back(
p[0] & 0xffffLL);
2031 APInt api = CFP->getValueAPF().bitcastToAPInt();
2036 assert(0 &&
"Unknown FP type!");
2038 }
else if (isa<ConstantDataSequential>(
C) &&
2039 cast<ConstantDataSequential>(
C)->isString()) {
2042 unsigned NumElts = Str->getNumElements();
2044 if (Str->isCString()) {
2049 AbbrevToUse = String8Abbrev;
2053 for (
unsigned i = 0;
i != NumElts; ++
i) {
2054 unsigned char V = Str->getElementAsInteger(
i);
2056 isCStr7 &= (V & 128) == 0;
2062 AbbrevToUse = CString6Abbrev;
2064 AbbrevToUse = CString7Abbrev;
2066 dyn_cast<ConstantDataSequential>(
C)) {
2069 if (isa<IntegerType>(EltTy)) {
2070 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i)
2071 Record.push_back(CDS->getElementAsInteger(
i));
2073 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i) {
2078 F = CDS->getElementAsFloat(
i);
2083 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i) {
2088 F = CDS->getElementAsDouble(
i);
2092 }
else if (isa<ConstantArray>(
C) || isa<ConstantStruct>(
C) ||
2093 isa<ConstantVector>(
C)) {
2095 for (
const Value *
Op :
C->operands())
2097 AbbrevToUse = AggregateAbbrev;
2098 }
else if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(
C)) {
2099 switch (
CE->getOpcode()) {
2104 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2106 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2108 assert(
CE->getNumOperands() == 2 &&
"Unknown constant expr!");
2118 case Instruction::GetElementPtr: {
2120 const auto *GO = cast<GEPOperator>(
C);
2121 if (GO->isInBounds())
2123 Record.push_back(getTypeID(GO->getSourceElementType()));
2124 for (
unsigned i = 0,
e =
CE->getNumOperands();
i !=
e; ++
i) {
2125 Record.push_back(getTypeID(
C->getOperand(
i)->getType()));
2136 case Instruction::ExtractElement:
2138 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2140 Record.push_back(getTypeID(
C->getOperand(1)->getType()));
2143 case Instruction::InsertElement:
2147 Record.push_back(getTypeID(
C->getOperand(2)->getType()));
2150 case Instruction::ShuffleVector:
2155 if (
C->getType() ==
C->getOperand(0)->getType()) {
2159 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2165 case Instruction::ICmp:
2166 case Instruction::FCmp:
2168 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2171 Record.push_back(
CE->getPredicate());
2174 }
else if (
const BlockAddress *BA = dyn_cast<BlockAddress>(
C)) {
2176 Record.push_back(getTypeID(BA->getFunction()->getType()));
2192 void DXILBitcodeWriter::writeModuleConstants() {
2197 for (
unsigned i = 0,
e = Vals.size();
i !=
e; ++
i) {
2198 if (!isa<GlobalValue>(Vals[
i].first)) {
2199 writeConstants(
i, Vals.size(),
true);
2213 bool DXILBitcodeWriter::pushValueAndType(
const Value *V,
unsigned InstID,
2217 Vals.push_back(InstID -
ValID);
2218 if (
ValID >= InstID) {
2219 Vals.push_back(getTypeID(V->
getType(), V));
2227 void DXILBitcodeWriter::pushValue(
const Value *V,
unsigned InstID,
2230 Vals.push_back(InstID -
ValID);
2233 void DXILBitcodeWriter::pushValueSigned(
const Value *V,
unsigned InstID,
2236 int64_t diff = ((int32_t)InstID - (int32_t)
ValID);
2241 void DXILBitcodeWriter::writeInstruction(
const Instruction &
I,
unsigned InstID,
2244 unsigned AbbrevToUse = 0;
2246 switch (
I.getOpcode()) {
2250 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2251 AbbrevToUse = (unsigned)FUNCTION_INST_CAST_ABBREV;
2252 Vals.push_back(getTypeID(
I.getType(), &
I));
2255 assert(isa<BinaryOperator>(
I) &&
"Unknown instruction!");
2257 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2258 AbbrevToUse = (unsigned)FUNCTION_INST_BINOP_ABBREV;
2259 pushValue(
I.getOperand(1), InstID, Vals);
2263 if (AbbrevToUse == (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2264 AbbrevToUse = (unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV;
2265 Vals.push_back(Flags);
2270 case Instruction::GetElementPtr: {
2272 AbbrevToUse = (unsigned)FUNCTION_INST_GEP_ABBREV;
2273 auto &GEPInst = cast<GetElementPtrInst>(
I);
2274 Vals.push_back(GEPInst.isInBounds());
2275 Vals.push_back(getTypeID(GEPInst.getSourceElementType()));
2276 for (
unsigned i = 0,
e =
I.getNumOperands();
i !=
e; ++
i)
2277 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2280 case Instruction::ExtractValue: {
2282 pushValueAndType(
I.getOperand(0), InstID, Vals);
2287 case Instruction::InsertValue: {
2289 pushValueAndType(
I.getOperand(0), InstID, Vals);
2290 pushValueAndType(
I.getOperand(1), InstID, Vals);
2297 pushValueAndType(
I.getOperand(1), InstID, Vals);
2298 pushValue(
I.getOperand(2), InstID, Vals);
2299 pushValueAndType(
I.getOperand(0), InstID, Vals);
2301 case Instruction::ExtractElement:
2303 pushValueAndType(
I.getOperand(0), InstID, Vals);
2304 pushValueAndType(
I.getOperand(1), InstID, Vals);
2306 case Instruction::InsertElement:
2308 pushValueAndType(
I.getOperand(0), InstID, Vals);
2309 pushValue(
I.getOperand(1), InstID, Vals);
2310 pushValueAndType(
I.getOperand(2), InstID, Vals);
2312 case Instruction::ShuffleVector:
2314 pushValueAndType(
I.getOperand(0), InstID, Vals);
2315 pushValue(
I.getOperand(1), InstID, Vals);
2316 pushValue(
I.getOperand(2), InstID, Vals);
2318 case Instruction::ICmp:
2319 case Instruction::FCmp: {
2322 pushValueAndType(
I.getOperand(0), InstID, Vals);
2323 pushValue(
I.getOperand(1), InstID, Vals);
2327 Vals.push_back(Flags);
2333 unsigned NumOperands =
I.getNumOperands();
2334 if (NumOperands == 0)
2335 AbbrevToUse = (unsigned)FUNCTION_INST_RET_VOID_ABBREV;
2336 else if (NumOperands == 1) {
2337 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2338 AbbrevToUse = (
unsigned)FUNCTION_INST_RET_VAL_ABBREV;
2340 for (
unsigned i = 0,
e = NumOperands;
i !=
e; ++
i)
2341 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2344 case Instruction::Br: {
2353 case Instruction::Switch: {
2356 Vals.push_back(getTypeID(
SI.getCondition()->getType()));
2357 pushValue(
SI.getCondition(), InstID, Vals);
2359 for (
auto Case :
SI.cases()) {
2360 Vals.push_back(VE.
getValueID(Case.getCaseValue()));
2361 Vals.push_back(VE.
getValueID(Case.getCaseSuccessor()));
2364 case Instruction::IndirectBr:
2366 Vals.push_back(getTypeID(
I.getOperand(0)->getType()));
2368 pushValue(
I.getOperand(0), InstID, Vals);
2369 for (
unsigned i = 1,
e =
I.getNumOperands();
i !=
e; ++
i)
2373 case Instruction::Invoke: {
2383 Vals.push_back(getTypeID(FTy));
2384 pushValueAndType(Callee, InstID, Vals);
2388 pushValue(
I.getOperand(
i), InstID, Vals);
2394 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2398 case Instruction::Resume:
2400 pushValueAndType(
I.getOperand(0), InstID, Vals);
2402 case Instruction::Unreachable:
2404 AbbrevToUse = (unsigned)FUNCTION_INST_UNREACHABLE_ABBREV;
2407 case Instruction::PHI: {
2408 const PHINode &PN = cast<PHINode>(
I);
2414 Vals64.push_back(getTypeID(PN.
getType()));
2420 Stream.EmitRecord(Code, Vals64, AbbrevToUse);
2425 case Instruction::LandingPad: {
2428 Vals.push_back(getTypeID(LP.
getType()));
2436 pushValueAndType(LP.
getClause(
I), InstID, Vals);
2441 case Instruction::Alloca: {
2445 Vals.push_back(getTypeID(
I.getOperand(0)->getType()));
2449 unsigned EncodedAlign = getEncodedAlign(AI.
getAlign());
2450 Bitfield::set<APV::AlignLower>(
2452 Bitfield::set<APV::AlignUpper>(
Record,
2460 if (cast<LoadInst>(
I).isAtomic()) {
2462 pushValueAndType(
I.getOperand(0), InstID, Vals);
2465 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2466 AbbrevToUse = (unsigned)FUNCTION_INST_LOAD_ABBREV;
2468 Vals.push_back(getTypeID(
I.getType()));
2470 Vals.push_back(cast<LoadInst>(
I).isVolatile());
2471 if (cast<LoadInst>(
I).isAtomic()) {
2473 Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(
I).getSyncScopeID()));
2477 if (cast<StoreInst>(
I).isAtomic())
2481 pushValueAndType(
I.getOperand(1), InstID, Vals);
2482 pushValueAndType(
I.getOperand(0), InstID, Vals);
2484 Vals.push_back(cast<StoreInst>(
I).isVolatile());
2485 if (cast<StoreInst>(
I).isAtomic()) {
2488 getEncodedSyncScopeID(cast<StoreInst>(
I).getSyncScopeID()));
2491 case Instruction::AtomicCmpXchg:
2493 pushValueAndType(
I.getOperand(0), InstID, Vals);
2494 pushValueAndType(
I.getOperand(1), InstID, Vals);
2495 pushValue(
I.getOperand(2), InstID, Vals);
2496 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isVolatile());
2500 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(
I).getSyncScopeID()));
2503 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isWeak());
2505 case Instruction::AtomicRMW:
2507 pushValueAndType(
I.getOperand(0), InstID, Vals);
2508 pushValue(
I.getOperand(1), InstID, Vals);
2511 Vals.push_back(cast<AtomicRMWInst>(
I).isVolatile());
2514 getEncodedSyncScopeID(cast<AtomicRMWInst>(
I).getSyncScopeID()));
2516 case Instruction::Fence:
2519 Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(
I).getSyncScopeID()));
2549 case Instruction::VAArg:
2551 Vals.push_back(getTypeID(
I.getOperand(0)->getType()));
2552 pushValue(
I.getOperand(0), InstID, Vals);
2553 Vals.push_back(getTypeID(
I.getType()));
2557 Stream.EmitRecord(Code, Vals, AbbrevToUse);
2562 void DXILBitcodeWriter::writeFunctionLevelValueSymbolTable(
2575 for (
auto &
VI : VST) {
2576 SortedTable.push_back(
VI.second->getValueName());
2579 std::sort(SortedTable.begin(), SortedTable.end(),
2581 return A->first() < B->first();
2589 bool isChar6 =
true;
2590 for (
const char *
C =
Name.getKeyData(), *
E =
C +
Name.getKeyLength();
2594 if ((
unsigned char)*
C & 128) {
2600 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
2605 if (isa<BasicBlock>(
SI->getValue())) {
2608 AbbrevToUse = VST_BBENTRY_6_ABBREV;
2612 AbbrevToUse = VST_ENTRY_6_ABBREV;
2614 AbbrevToUse = VST_ENTRY_7_ABBREV;
2618 for (
const char *
P =
Name.getKeyData(),
2619 *
E =
Name.getKeyData() +
Name.getKeyLength();
2621 NameVals.push_back((
unsigned char)*
P);
2624 Stream.EmitRecord(Code, NameVals, AbbrevToUse);
2630 void DXILBitcodeWriter::writeUseList(
UseListOrder &&Order) {
2631 assert(Order.Shuffle.size() >= 2 &&
"Shuffle too small");
2633 if (isa<BasicBlock>(Order.V))
2643 void DXILBitcodeWriter::writeUseListBlock(
const Function *
F) {
2644 auto hasMore = [&]() {
2660 void DXILBitcodeWriter::writeFunction(
const Function &
F) {
2673 unsigned CstStart, CstEnd;
2675 writeConstants(CstStart, CstEnd,
false);
2678 writeFunctionMetadata(
F);
2681 unsigned InstID = CstEnd;
2683 bool NeedsMetadataAttachment =
F.hasMetadata();
2691 writeInstruction(*
I, InstID, Vals);
2693 if (!
I->getType()->isVoidTy())
2697 NeedsMetadataAttachment |=
I->hasMetadataOtherThanDebugLoc();
2710 Vals.push_back(
DL->getLine());
2711 Vals.push_back(
DL->getColumn());
2721 if (
auto *Symtab =
F.getValueSymbolTable())
2722 writeFunctionLevelValueSymbolTable(*Symtab);
2724 if (NeedsMetadataAttachment)
2725 writeFunctionMetadataAttachment(
F);
2727 writeUseListBlock(&
F);
2733 void DXILBitcodeWriter::writeBlockInfo() {
2737 Stream.EnterBlockInfoBlock();
2740 auto Abbv = std::make_shared<BitCodeAbbrev>();
2747 assert(
false &&
"Unexpected abbrev ordering!");
2751 auto Abbv = std::make_shared<BitCodeAbbrev>();
2758 assert(
false &&
"Unexpected abbrev ordering!");
2761 auto Abbv = std::make_shared<BitCodeAbbrev>();
2768 assert(
false &&
"Unexpected abbrev ordering!");
2771 auto Abbv = std::make_shared<BitCodeAbbrev>();
2777 std::move(Abbv)) != VST_BBENTRY_6_ABBREV)
2778 assert(
false &&
"Unexpected abbrev ordering!");
2782 auto Abbv = std::make_shared<BitCodeAbbrev>();
2787 CONSTANTS_SETTYPE_ABBREV)
2788 assert(
false &&
"Unexpected abbrev ordering!");
2792 auto Abbv = std::make_shared<BitCodeAbbrev>();
2796 CONSTANTS_INTEGER_ABBREV)
2797 assert(
false &&
"Unexpected abbrev ordering!");
2801 auto Abbv = std::make_shared<BitCodeAbbrev>();
2809 CONSTANTS_CE_CAST_Abbrev)
2810 assert(
false &&
"Unexpected abbrev ordering!");
2813 auto Abbv = std::make_shared<BitCodeAbbrev>();
2816 CONSTANTS_NULL_Abbrev)
2817 assert(
false &&
"Unexpected abbrev ordering!");
2823 auto Abbv = std::make_shared<BitCodeAbbrev>();
2831 (
unsigned)FUNCTION_INST_LOAD_ABBREV)
2832 assert(
false &&
"Unexpected abbrev ordering!");
2835 auto Abbv = std::make_shared<BitCodeAbbrev>();
2841 (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2842 assert(
false &&
"Unexpected abbrev ordering!");
2845 auto Abbv = std::make_shared<BitCodeAbbrev>();
2852 (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV)
2853 assert(
false &&
"Unexpected abbrev ordering!");
2856 auto Abbv = std::make_shared<BitCodeAbbrev>();
2863 (
unsigned)FUNCTION_INST_CAST_ABBREV)
2864 assert(
false &&
"Unexpected abbrev ordering!");
2868 auto Abbv = std::make_shared<BitCodeAbbrev>();
2871 (
unsigned)FUNCTION_INST_RET_VOID_ABBREV)
2872 assert(
false &&
"Unexpected abbrev ordering!");
2875 auto Abbv = std::make_shared<BitCodeAbbrev>();
2879 (
unsigned)FUNCTION_INST_RET_VAL_ABBREV)
2880 assert(
false &&
"Unexpected abbrev ordering!");
2883 auto Abbv = std::make_shared<BitCodeAbbrev>();
2886 (
unsigned)FUNCTION_INST_UNREACHABLE_ABBREV)
2887 assert(
false &&
"Unexpected abbrev ordering!");
2890 auto Abbv = std::make_shared<BitCodeAbbrev>();
2898 (
unsigned)FUNCTION_INST_GEP_ABBREV)
2899 assert(
false &&
"Unexpected abbrev ordering!");
2905 void DXILBitcodeWriter::writeModuleVersion() {
2920 DXILBitcodeWriter::writeModuleVersion();
2926 writeAttributeGroupTable();
2929 writeAttributeTable();
2941 writeModuleConstants();
2944 writeModuleMetadataKinds();
2947 writeModuleMetadata();
2952 writeFunctionLevelValueSymbolTable(
M.getValueSymbolTable());
2955 writeUseListBlock(
nullptr);
2959 if (!
F.isDeclaration())