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())
627 unsigned AbbrevToUse) {
638 Stream.EmitRecord(Code, Vals, AbbrevToUse);
643 case Attribute::Alignment:
645 case Attribute::AlwaysInline:
647 case Attribute::ArgMemOnly:
649 case Attribute::Builtin:
651 case Attribute::ByVal:
655 case Attribute::InAlloca:
659 case Attribute::InlineHint:
661 case Attribute::InReg:
665 case Attribute::MinSize:
667 case Attribute::Naked:
669 case Attribute::Nest:
671 case Attribute::NoAlias:
673 case Attribute::NoBuiltin:
675 case Attribute::NoCapture:
677 case Attribute::NoDuplicate:
679 case Attribute::NoImplicitFloat:
681 case Attribute::NoInline:
683 case Attribute::NonLazyBind:
685 case Attribute::NonNull:
687 case Attribute::Dereferenceable:
689 case Attribute::DereferenceableOrNull:
691 case Attribute::NoRedZone:
693 case Attribute::NoReturn:
695 case Attribute::NoUnwind:
697 case Attribute::OptimizeForSize:
699 case Attribute::OptimizeNone:
701 case Attribute::ReadNone:
703 case Attribute::ReadOnly:
705 case Attribute::Returned:
707 case Attribute::ReturnsTwice:
709 case Attribute::SExt:
711 case Attribute::StackAlignment:
713 case Attribute::StackProtect:
715 case Attribute::StackProtectReq:
717 case Attribute::StackProtectStrong:
719 case Attribute::SafeStack:
721 case Attribute::StructRet:
723 case Attribute::SanitizeAddress:
725 case Attribute::SanitizeThread:
727 case Attribute::SanitizeMemory:
729 case Attribute::UWTable:
731 case Attribute::ZExt:
742 "should be stripped in DXILPrepare");
751 Vals.push_back(V << 1);
753 Vals.push_back((-V << 1) | 1);
762 unsigned NumWords = A.getActiveWords();
763 const uint64_t *RawData = A.getRawData();
764 for (
unsigned i = 0;
i < NumWords;
i++)
771 if (
const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
772 if (OBO->hasNoSignedWrap())
774 if (OBO->hasNoUnsignedWrap())
776 }
else if (
const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
779 }
else if (
const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
780 if (FPMO->hasAllowReassoc())
782 if (FPMO->hasNoNaNs())
784 if (FPMO->hasNoInfs())
786 if (FPMO->hasNoSignedZeros())
788 if (FPMO->hasAllowReciprocal())
790 if (FPMO->hasAllowContract())
792 if (FPMO->hasApproxFunc())
873 switch (
C.getSelectionKind()) {
892 void DXILBitcodeWriter::writeAttributeGroupTable() {
893 const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
895 if (AttrGrps.empty())
902 unsigned AttrListIndex = Pair.first;
905 Record.push_back(AttrListIndex);
908 if (Attr.isEnumAttribute()) {
911 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
914 }
else if (Attr.isIntAttribute()) {
917 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
920 Record.push_back(Attr.getValueAsInt());
942 void DXILBitcodeWriter::writeAttributeTable() {
952 for (
unsigned i :
AL.indexes()) {
966 void DXILBitcodeWriter::writeTypeTable() {
975 auto Abbv = std::make_shared<BitCodeAbbrev>();
982 Abbv = std::make_shared<BitCodeAbbrev>();
990 Abbv = std::make_shared<BitCodeAbbrev>();
998 Abbv = std::make_shared<BitCodeAbbrev>();
1005 Abbv = std::make_shared<BitCodeAbbrev>();
1013 Abbv = std::make_shared<BitCodeAbbrev>();
1020 TypeVals.push_back(TypeList.size());
1025 for (
Type *
T : TypeList) {
1026 int AbbrevToUse = 0;
1029 switch (
T->getTypeID()) {
1068 TypeVals.push_back(cast<IntegerType>(
T)->
getBitWidth());
1078 AbbrevToUse = PtrAbbrev;
1089 TypeVals.push_back(
false);
1092 "dxilOpaquePtrReservedName", StructNameAbbrev);
1098 AbbrevToUse = PtrAbbrev;
1106 TypeVals.push_back(FT->
isVarArg());
1109 TypeVals.push_back(getTypeID(PTy));
1110 AbbrevToUse = FunctionAbbrev;
1116 TypeVals.push_back(
ST->isPacked());
1118 for (
Type *ElTy :
ST->elements())
1119 TypeVals.push_back(getTypeID(ElTy));
1121 if (
ST->isLiteral()) {
1123 AbbrevToUse = StructAnonAbbrev;
1125 if (
ST->isOpaque()) {
1129 AbbrevToUse = StructNamedAbbrev;
1133 if (!
ST->getName().empty())
1145 AbbrevToUse = ArrayAbbrev;
1160 Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
1167 void DXILBitcodeWriter::writeComdats() {
1172 size_t Size =
C->getName().size();
1174 Vals.push_back(Size);
1175 for (
char Chr :
C->getName())
1176 Vals.push_back((
unsigned char)Chr);
1182 void DXILBitcodeWriter::writeValueSymbolTableForwardDecl() {}
1187 void DXILBitcodeWriter::writeModuleInfo() {
1189 if (!
M.getTargetTriple().empty())
1192 const std::string &
DL =
M.getDataLayoutStr();
1195 if (!
M.getModuleInlineAsm().empty())
1201 std::map<std::string, unsigned> SectionMap;
1202 std::map<std::string, unsigned> GCMap;
1204 unsigned MaxGlobalType = 0;
1205 const auto UpdateMaxAlignment = [&MaxAlignment](
const MaybeAlign A) {
1207 MaxAlignment = !MaxAlignment ? *
A :
std::max(*MaxAlignment, *A);
1210 UpdateMaxAlignment(GV.getAlign());
1211 MaxGlobalType =
std::max(MaxGlobalType, getTypeID(GV.getValueType(), &GV));
1212 if (GV.hasSection()) {
1214 unsigned &Entry = SectionMap[std::string(GV.getSection())];
1217 GV.getSection(), 0 );
1218 Entry = SectionMap.size();
1223 UpdateMaxAlignment(
F.getAlign());
1224 if (
F.hasSection()) {
1226 unsigned &Entry = SectionMap[std::string(
F.getSection())];
1230 Entry = SectionMap.size();
1235 unsigned &Entry = GCMap[
F.getGC()];
1239 Entry = GCMap.size();
1245 unsigned SimpleGVarAbbrev = 0;
1246 if (!
M.global_empty()) {
1249 auto Abbv = std::make_shared<BitCodeAbbrev>();
1261 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1265 if (SectionMap.empty())
1277 unsigned AbbrevToUse = 0;
1283 Vals.push_back(getTypeID(GV.getValueType(), &GV));
1285 GV.getType()->getAddressSpace() << 2 | 2 |
1286 (GV.isConstant() ? 1 : 0));
1289 GV.isDeclaration() ? 0 : (VE.
getValueID(GV.getInitializer()) + 1));
1291 Vals.push_back(getEncodedAlign(GV.getAlign()));
1292 Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1294 if (GV.isThreadLocal() ||
1297 GV.isExternallyInitialized() ||
1303 Vals.push_back(GV.isExternallyInitialized());
1305 Vals.push_back(GV.hasComdat() ? VE.
getComdatID(GV.getComdat()) : 0);
1307 AbbrevToUse = SimpleGVarAbbrev;
1319 Vals.push_back(getTypeID(
F.getFunctionType(), &
F));
1320 Vals.push_back(
F.getCallingConv());
1321 Vals.push_back(
F.isDeclaration());
1324 Vals.push_back(getEncodedAlign(
F.getAlign()));
1325 Vals.push_back(
F.hasSection() ? SectionMap[std::string(
F.getSection())]
1328 Vals.push_back(
F.hasGC() ? GCMap[
F.getGC()] : 0);
1331 F.hasPrologueData() ? (VE.
getValueID(
F.getPrologueData()) + 1) : 0);
1333 Vals.push_back(
F.hasComdat() ? VE.
getComdatID(
F.getComdat()) : 0);
1334 Vals.push_back(
F.hasPrefixData() ? (VE.
getValueID(
F.getPrefixData()) + 1)
1337 F.hasPersonalityFn() ? (VE.
getValueID(
F.getPersonalityFn()) + 1) : 0);
1339 unsigned AbbrevToUse = 0;
1347 Vals.push_back(getTypeID(
A.getValueType(), &A));
1354 unsigned AbbrevToUse = 0;
1360 void DXILBitcodeWriter::writeValueAsMetadata(
1365 if (
Function *
F = dyn_cast<Function>(V))
1369 Record.push_back(getTypeID(Ty));
1375 void DXILBitcodeWriter::writeMDTuple(
const MDTuple *
N,
1378 for (
unsigned i = 0,
e =
N->getNumOperands();
i !=
e; ++
i) {
1380 assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1381 "Unexpected function-local metadata");
1390 void DXILBitcodeWriter::writeDILocation(
const DILocation *
N,
1394 Abbrev = createDILocationAbbrev();
1395 Record.push_back(
N->isDistinct());
1396 Record.push_back(
N->getLine());
1397 Record.push_back(
N->getColumn());
1408 return I < 0 ? ~(U << 1) : U << 1;
1415 void DXILBitcodeWriter::writeDISubrange(
const DISubrange *
N,
1418 Record.push_back(
N->isDistinct());
1427 void DXILBitcodeWriter::writeDIEnumerator(
const DIEnumerator *
N,
1430 Record.push_back(
N->isDistinct());
1438 void DXILBitcodeWriter::writeDIBasicType(
const DIBasicType *
N,
1441 Record.push_back(
N->isDistinct());
1442 Record.push_back(
N->getTag());
1444 Record.push_back(
N->getSizeInBits());
1445 Record.push_back(
N->getAlignInBits());
1446 Record.push_back(
N->getEncoding());
1452 void DXILBitcodeWriter::writeDIDerivedType(
const DIDerivedType *
N,
1455 Record.push_back(
N->isDistinct());
1456 Record.push_back(
N->getTag());
1459 Record.push_back(
N->getLine());
1462 Record.push_back(
N->getSizeInBits());
1463 Record.push_back(
N->getAlignInBits());
1464 Record.push_back(
N->getOffsetInBits());
1465 Record.push_back(
N->getFlags());
1475 Record.push_back(
N->isDistinct());
1476 Record.push_back(
N->getTag());
1479 Record.push_back(
N->getLine());
1482 Record.push_back(
N->getSizeInBits());
1483 Record.push_back(
N->getAlignInBits());
1484 Record.push_back(
N->getOffsetInBits());
1485 Record.push_back(
N->getFlags());
1487 Record.push_back(
N->getRuntimeLang());
1499 Record.push_back(
N->isDistinct());
1500 Record.push_back(
N->getFlags());
1507 void DXILBitcodeWriter::writeDIFile(
const DIFile *
N,
1510 Record.push_back(
N->isDistinct());
1518 void DXILBitcodeWriter::writeDICompileUnit(
const DICompileUnit *
N,
1521 Record.push_back(
N->isDistinct());
1522 Record.push_back(
N->getSourceLanguage());
1525 Record.push_back(
N->isOptimized());
1527 Record.push_back(
N->getRuntimeVersion());
1529 Record.push_back(
N->getEmissionKind());
1535 Record.push_back(
N->getDWOId());
1541 void DXILBitcodeWriter::writeDISubprogram(
const DISubprogram *
N,
1544 Record.push_back(
N->isDistinct());
1549 Record.push_back(
N->getLine());
1551 Record.push_back(
N->isLocalToUnit());
1552 Record.push_back(
N->isDefinition());
1553 Record.push_back(
N->getScopeLine());
1555 Record.push_back(
N->getVirtuality());
1556 Record.push_back(
N->getVirtualIndex());
1557 Record.push_back(
N->getFlags());
1558 Record.push_back(
N->isOptimized());
1571 Record.push_back(
N->isDistinct());
1574 Record.push_back(
N->getLine());
1575 Record.push_back(
N->getColumn());
1581 void DXILBitcodeWriter::writeDILexicalBlockFile(
1584 Record.push_back(
N->isDistinct());
1587 Record.push_back(
N->getDiscriminator());
1593 void DXILBitcodeWriter::writeDINamespace(
const DINamespace *
N,
1596 Record.push_back(
N->isDistinct());
1606 void DXILBitcodeWriter::writeDIModule(
const DIModule *
N,
1609 Record.push_back(
N->isDistinct());
1610 for (
auto &
I :
N->operands())
1617 void DXILBitcodeWriter::writeDITemplateTypeParameter(
1620 Record.push_back(
N->isDistinct());
1628 void DXILBitcodeWriter::writeDITemplateValueParameter(
1631 Record.push_back(
N->isDistinct());
1632 Record.push_back(
N->getTag());
1644 Record.push_back(
N->isDistinct());
1649 Record.push_back(
N->getLine());
1651 Record.push_back(
N->isLocalToUnit());
1652 Record.push_back(
N->isDefinition());
1663 Record.push_back(
N->isDistinct());
1664 Record.push_back(
N->getTag());
1668 Record.push_back(
N->getLine());
1670 Record.push_back(
N->getArg());
1671 Record.push_back(
N->getFlags());
1677 void DXILBitcodeWriter::writeDIExpression(
const DIExpression *
N,
1680 Record.reserve(
N->getElements().size() + 1);
1682 Record.push_back(
N->isDistinct());
1683 Record.append(
N->elements_begin(),
N->elements_end());
1698 Record.push_back(
N->isDistinct());
1699 Record.push_back(
N->getTag());
1702 Record.push_back(
N->getLine());
1709 unsigned DXILBitcodeWriter::createDILocationAbbrev() {
1714 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1724 unsigned DXILBitcodeWriter::createGenericDINodeAbbrev() {
1729 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1742 std::vector<unsigned> *MDAbbrevs,
1743 std::vector<uint64_t> *IndexPos) {
1748 #define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
1749 #include "llvm/IR/Metadata.def"
1753 IndexPos->push_back(
Stream.GetCurrentBitNo());
1754 if (
const MDNode *
N = dyn_cast<MDNode>(MD)) {
1755 assert(
N->isResolved() &&
"Expected forward references to be resolved");
1757 switch (
N->getMetadataID()) {
1760 #define HANDLE_MDNODE_LEAF(CLASS) \
1761 case Metadata::CLASS##Kind: \
1763 write##CLASS(cast<CLASS>(N), Record, \
1764 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
1766 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
1768 #include "llvm/IR/Metadata.def"
1771 writeValueAsMetadata(cast<ValueAsMetadata>(MD),
Record);
1775 unsigned DXILBitcodeWriter::createMetadataStringsAbbrev() {
1776 auto Abbv = std::make_shared<BitCodeAbbrev>();
1783 void DXILBitcodeWriter::writeMetadataStrings(
1785 for (
const Metadata *MD : Strings) {
1786 const MDString *MDS = cast<MDString>(MD);
1792 createMetadataStringsAbbrev());
1797 void DXILBitcodeWriter::writeModuleMetadata() {
1798 if (!VE.
hasMDs() &&
M.named_metadata_empty())
1805 std::vector<unsigned> MDAbbrevs;
1808 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
1809 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
1810 createGenericDINodeAbbrev();
1812 unsigned NameAbbrev = 0;
1813 if (!
M.named_metadata_empty()) {
1815 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1825 std::vector<uint64_t> IndexPos;
1833 Record.append(Str.bytes_begin(), Str.bytes_end());
1838 for (
const MDNode *
N : NMD.operands())
1847 void DXILBitcodeWriter::writeFunctionMetadata(
const Function &
F) {
1858 void DXILBitcodeWriter::writeFunctionMetadataAttachment(
const Function &
F) {
1866 F.getAllMetadata(MDs);
1868 for (
const auto &
I : MDs) {
1879 I.getAllMetadataOtherThanDebugLoc(MDs);
1887 for (
unsigned i = 0,
e = MDs.size();
i !=
e; ++
i) {
1888 Record.push_back(MDs[
i].first);
1898 void DXILBitcodeWriter::writeModuleMetadataKinds() {
1904 M.getMDKindNames(Names);
1911 for (
unsigned MDKindID = 0,
e = Names.size(); MDKindID !=
e; ++MDKindID) {
1912 Record.push_back(MDKindID);
1923 void DXILBitcodeWriter::writeConstants(
unsigned FirstVal,
unsigned LastVal,
1925 if (FirstVal == LastVal)
1930 unsigned AggregateAbbrev = 0;
1931 unsigned String8Abbrev = 0;
1932 unsigned CString7Abbrev = 0;
1933 unsigned CString6Abbrev = 0;
1937 auto Abbv = std::make_shared<BitCodeAbbrev>();
1945 Abbv = std::make_shared<BitCodeAbbrev>();
1951 Abbv = std::make_shared<BitCodeAbbrev>();
1957 Abbv = std::make_shared<BitCodeAbbrev>();
1967 Type *LastTy =
nullptr;
1968 for (
unsigned i = FirstVal;
i != LastVal; ++
i) {
1969 const Value *V = Vals[
i].first;
1973 Record.push_back(getTypeID(LastTy));
1975 CONSTANTS_SETTYPE_ABBREV);
1979 if (
const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
1980 Record.push_back(
unsigned(IA->hasSideEffects()) |
1981 unsigned(IA->isAlignStack()) << 1 |
1982 unsigned(IA->getDialect() & 1) << 2);
1985 const std::string &AsmStr = IA->getAsmString();
1986 Record.push_back(AsmStr.size());
1987 Record.append(AsmStr.begin(), AsmStr.end());
1990 const std::string &ConstraintStr = IA->getConstraintString();
1991 Record.push_back(ConstraintStr.size());
1992 Record.append(ConstraintStr.begin(), ConstraintStr.end());
1998 unsigned Code = -1U;
1999 unsigned AbbrevToUse = 0;
2000 if (
C->isNullValue()) {
2002 }
else if (isa<UndefValue>(
C)) {
2005 if (
IV->getBitWidth() <= 64) {
2009 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2015 unsigned NWords =
IV->getValue().getActiveWords();
2016 const uint64_t *RawWords =
IV->getValue().getRawData();
2017 for (
unsigned i = 0;
i != NWords; ++
i) {
2022 }
else if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(
C)) {
2024 Type *Ty = CFP->getType();
2026 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2030 APInt api = CFP->getValueAPF().bitcastToAPInt();
2032 Record.push_back((
p[1] << 48) | (
p[0] >> 16));
2033 Record.push_back(
p[0] & 0xffffLL);
2035 APInt api = CFP->getValueAPF().bitcastToAPInt();
2040 assert(0 &&
"Unknown FP type!");
2042 }
else if (isa<ConstantDataSequential>(
C) &&
2043 cast<ConstantDataSequential>(
C)->isString()) {
2046 unsigned NumElts = Str->getNumElements();
2048 if (Str->isCString()) {
2053 AbbrevToUse = String8Abbrev;
2057 for (
unsigned i = 0;
i != NumElts; ++
i) {
2058 unsigned char V = Str->getElementAsInteger(
i);
2060 isCStr7 &= (V & 128) == 0;
2066 AbbrevToUse = CString6Abbrev;
2068 AbbrevToUse = CString7Abbrev;
2070 dyn_cast<ConstantDataSequential>(
C)) {
2073 if (isa<IntegerType>(EltTy)) {
2074 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i)
2075 Record.push_back(CDS->getElementAsInteger(
i));
2077 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i) {
2082 F = CDS->getElementAsFloat(
i);
2087 for (
unsigned i = 0,
e = CDS->getNumElements();
i !=
e; ++
i) {
2092 F = CDS->getElementAsDouble(
i);
2096 }
else if (isa<ConstantArray>(
C) || isa<ConstantStruct>(
C) ||
2097 isa<ConstantVector>(
C)) {
2099 for (
const Value *
Op :
C->operands())
2101 AbbrevToUse = AggregateAbbrev;
2102 }
else if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(
C)) {
2103 switch (
CE->getOpcode()) {
2108 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2110 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2112 assert(
CE->getNumOperands() == 2 &&
"Unknown constant expr!");
2122 case Instruction::GetElementPtr: {
2124 const auto *GO = cast<GEPOperator>(
C);
2125 if (GO->isInBounds())
2127 Record.push_back(getTypeID(GO->getSourceElementType()));
2128 for (
unsigned i = 0,
e =
CE->getNumOperands();
i !=
e; ++
i) {
2129 Record.push_back(getTypeID(
C->getOperand(
i)->getType()));
2140 case Instruction::ExtractElement:
2142 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2144 Record.push_back(getTypeID(
C->getOperand(1)->getType()));
2147 case Instruction::InsertElement:
2151 Record.push_back(getTypeID(
C->getOperand(2)->getType()));
2154 case Instruction::ShuffleVector:
2159 if (
C->getType() ==
C->getOperand(0)->getType()) {
2163 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2169 case Instruction::ICmp:
2170 case Instruction::FCmp:
2172 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2175 Record.push_back(
CE->getPredicate());
2178 }
else if (
const BlockAddress *BA = dyn_cast<BlockAddress>(
C)) {
2180 Record.push_back(getTypeID(BA->getFunction()->getType()));
2196 void DXILBitcodeWriter::writeModuleConstants() {
2201 for (
unsigned i = 0,
e = Vals.size();
i !=
e; ++
i) {
2202 if (!isa<GlobalValue>(Vals[
i].first)) {
2203 writeConstants(
i, Vals.size(),
true);
2217 bool DXILBitcodeWriter::pushValueAndType(
const Value *V,
unsigned InstID,
2221 Vals.push_back(InstID -
ValID);
2222 if (
ValID >= InstID) {
2223 Vals.push_back(getTypeID(V->
getType(), V));
2231 void DXILBitcodeWriter::pushValue(
const Value *V,
unsigned InstID,
2234 Vals.push_back(InstID -
ValID);
2237 void DXILBitcodeWriter::pushValueSigned(
const Value *V,
unsigned InstID,
2240 int64_t diff = ((int32_t)InstID - (int32_t)
ValID);
2245 void DXILBitcodeWriter::writeInstruction(
const Instruction &
I,
unsigned InstID,
2248 unsigned AbbrevToUse = 0;
2250 switch (
I.getOpcode()) {
2254 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2255 AbbrevToUse = (unsigned)FUNCTION_INST_CAST_ABBREV;
2256 Vals.push_back(getTypeID(
I.getType(), &
I));
2259 assert(isa<BinaryOperator>(
I) &&
"Unknown instruction!");
2261 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2262 AbbrevToUse = (unsigned)FUNCTION_INST_BINOP_ABBREV;
2263 pushValue(
I.getOperand(1), InstID, Vals);
2267 if (AbbrevToUse == (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2268 AbbrevToUse = (unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV;
2269 Vals.push_back(Flags);
2274 case Instruction::GetElementPtr: {
2276 AbbrevToUse = (unsigned)FUNCTION_INST_GEP_ABBREV;
2277 auto &GEPInst = cast<GetElementPtrInst>(
I);
2278 Vals.push_back(GEPInst.isInBounds());
2279 Vals.push_back(getTypeID(GEPInst.getSourceElementType()));
2280 for (
unsigned i = 0,
e =
I.getNumOperands();
i !=
e; ++
i)
2281 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2284 case Instruction::ExtractValue: {
2286 pushValueAndType(
I.getOperand(0), InstID, Vals);
2291 case Instruction::InsertValue: {
2293 pushValueAndType(
I.getOperand(0), InstID, Vals);
2294 pushValueAndType(
I.getOperand(1), InstID, Vals);
2301 pushValueAndType(
I.getOperand(1), InstID, Vals);
2302 pushValue(
I.getOperand(2), InstID, Vals);
2303 pushValueAndType(
I.getOperand(0), InstID, Vals);
2305 case Instruction::ExtractElement:
2307 pushValueAndType(
I.getOperand(0), InstID, Vals);
2308 pushValueAndType(
I.getOperand(1), InstID, Vals);
2310 case Instruction::InsertElement:
2312 pushValueAndType(
I.getOperand(0), InstID, Vals);
2313 pushValue(
I.getOperand(1), InstID, Vals);
2314 pushValueAndType(
I.getOperand(2), InstID, Vals);
2316 case Instruction::ShuffleVector:
2318 pushValueAndType(
I.getOperand(0), InstID, Vals);
2319 pushValue(
I.getOperand(1), InstID, Vals);
2320 pushValue(
I.getOperand(2), InstID, Vals);
2322 case Instruction::ICmp:
2323 case Instruction::FCmp: {
2326 pushValueAndType(
I.getOperand(0), InstID, Vals);
2327 pushValue(
I.getOperand(1), InstID, Vals);
2331 Vals.push_back(Flags);
2337 unsigned NumOperands =
I.getNumOperands();
2338 if (NumOperands == 0)
2339 AbbrevToUse = (unsigned)FUNCTION_INST_RET_VOID_ABBREV;
2340 else if (NumOperands == 1) {
2341 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2342 AbbrevToUse = (
unsigned)FUNCTION_INST_RET_VAL_ABBREV;
2344 for (
unsigned i = 0,
e = NumOperands;
i !=
e; ++
i)
2345 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2348 case Instruction::Br: {
2357 case Instruction::Switch: {
2360 Vals.push_back(getTypeID(
SI.getCondition()->getType()));
2361 pushValue(
SI.getCondition(), InstID, Vals);
2363 for (
auto Case :
SI.cases()) {
2364 Vals.push_back(VE.
getValueID(Case.getCaseValue()));
2365 Vals.push_back(VE.
getValueID(Case.getCaseSuccessor()));
2368 case Instruction::IndirectBr:
2370 Vals.push_back(getTypeID(
I.getOperand(0)->getType()));
2372 pushValue(
I.getOperand(0), InstID, Vals);
2373 for (
unsigned i = 1,
e =
I.getNumOperands();
i !=
e; ++
i)
2377 case Instruction::Invoke: {
2387 Vals.push_back(getTypeID(FTy));
2388 pushValueAndType(Callee, InstID, Vals);
2392 pushValue(
I.getOperand(
i), InstID, Vals);
2398 pushValueAndType(
I.getOperand(
i), InstID, Vals);
2402 case Instruction::Resume:
2404 pushValueAndType(
I.getOperand(0), InstID, Vals);
2406 case Instruction::Unreachable:
2408 AbbrevToUse = (unsigned)FUNCTION_INST_UNREACHABLE_ABBREV;
2411 case Instruction::PHI: {
2412 const PHINode &PN = cast<PHINode>(
I);
2418 Vals64.push_back(getTypeID(PN.
getType()));
2424 Stream.EmitRecord(Code, Vals64, AbbrevToUse);
2429 case Instruction::LandingPad: {
2432 Vals.push_back(getTypeID(LP.
getType()));
2440 pushValueAndType(LP.
getClause(
I), InstID, Vals);
2445 case Instruction::Alloca: {
2449 Vals.push_back(getTypeID(
I.getOperand(0)->getType()));
2453 unsigned EncodedAlign = getEncodedAlign(AI.
getAlign());
2454 Bitfield::set<APV::AlignLower>(
2456 Bitfield::set<APV::AlignUpper>(
Record,
2464 if (cast<LoadInst>(
I).isAtomic()) {
2466 pushValueAndType(
I.getOperand(0), InstID, Vals);
2469 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2470 AbbrevToUse = (unsigned)FUNCTION_INST_LOAD_ABBREV;
2472 Vals.push_back(getTypeID(
I.getType()));
2474 Vals.push_back(cast<LoadInst>(
I).isVolatile());
2475 if (cast<LoadInst>(
I).isAtomic()) {
2477 Vals.push_back(getEncodedSyncScopeID(cast<LoadInst>(
I).getSyncScopeID()));
2481 if (cast<StoreInst>(
I).isAtomic())
2485 pushValueAndType(
I.getOperand(1), InstID, Vals);
2486 pushValueAndType(
I.getOperand(0), InstID, Vals);
2488 Vals.push_back(cast<StoreInst>(
I).isVolatile());
2489 if (cast<StoreInst>(
I).isAtomic()) {
2492 getEncodedSyncScopeID(cast<StoreInst>(
I).getSyncScopeID()));
2495 case Instruction::AtomicCmpXchg:
2497 pushValueAndType(
I.getOperand(0), InstID, Vals);
2498 pushValueAndType(
I.getOperand(1), InstID, Vals);
2499 pushValue(
I.getOperand(2), InstID, Vals);
2500 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isVolatile());
2504 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(
I).getSyncScopeID()));
2507 Vals.push_back(cast<AtomicCmpXchgInst>(
I).isWeak());
2509 case Instruction::AtomicRMW:
2511 pushValueAndType(
I.getOperand(0), InstID, Vals);
2512 pushValue(
I.getOperand(1), InstID, Vals);
2515 Vals.push_back(cast<AtomicRMWInst>(
I).isVolatile());
2518 getEncodedSyncScopeID(cast<AtomicRMWInst>(
I).getSyncScopeID()));
2520 case Instruction::Fence:
2523 Vals.push_back(getEncodedSyncScopeID(cast<FenceInst>(
I).getSyncScopeID()));
2553 case Instruction::VAArg:
2555 Vals.push_back(getTypeID(
I.getOperand(0)->getType()));
2556 pushValue(
I.getOperand(0), InstID, Vals);
2557 Vals.push_back(getTypeID(
I.getType()));
2561 Stream.EmitRecord(Code, Vals, AbbrevToUse);
2566 void DXILBitcodeWriter::writeFunctionLevelValueSymbolTable(
2579 for (
auto &
VI : VST) {
2580 SortedTable.push_back(
VI.second->getValueName());
2583 std::sort(SortedTable.begin(), SortedTable.end(),
2585 return A->first() < B->first();
2593 bool isChar6 =
true;
2594 for (
const char *
C =
Name.getKeyData(), *
E =
C +
Name.getKeyLength();
2598 if ((
unsigned char)*
C & 128) {
2604 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
2609 if (isa<BasicBlock>(
SI->getValue())) {
2612 AbbrevToUse = VST_BBENTRY_6_ABBREV;
2616 AbbrevToUse = VST_ENTRY_6_ABBREV;
2618 AbbrevToUse = VST_ENTRY_7_ABBREV;
2622 for (
const char *
P =
Name.getKeyData(),
2623 *
E =
Name.getKeyData() +
Name.getKeyLength();
2625 NameVals.push_back((
unsigned char)*
P);
2628 Stream.EmitRecord(Code, NameVals, AbbrevToUse);
2634 void DXILBitcodeWriter::writeUseList(
UseListOrder &&Order) {
2635 assert(Order.Shuffle.size() >= 2 &&
"Shuffle too small");
2637 if (isa<BasicBlock>(Order.V))
2647 void DXILBitcodeWriter::writeUseListBlock(
const Function *
F) {
2648 auto hasMore = [&]() {
2664 void DXILBitcodeWriter::writeFunction(
const Function &
F) {
2677 unsigned CstStart, CstEnd;
2679 writeConstants(CstStart, CstEnd,
false);
2682 writeFunctionMetadata(
F);
2685 unsigned InstID = CstEnd;
2687 bool NeedsMetadataAttachment =
F.hasMetadata();
2695 writeInstruction(*
I, InstID, Vals);
2697 if (!
I->getType()->isVoidTy())
2701 NeedsMetadataAttachment |=
I->hasMetadataOtherThanDebugLoc();
2714 Vals.push_back(
DL->getLine());
2715 Vals.push_back(
DL->getColumn());
2725 if (
auto *Symtab =
F.getValueSymbolTable())
2726 writeFunctionLevelValueSymbolTable(*Symtab);
2728 if (NeedsMetadataAttachment)
2729 writeFunctionMetadataAttachment(
F);
2731 writeUseListBlock(&
F);
2737 void DXILBitcodeWriter::writeBlockInfo() {
2741 Stream.EnterBlockInfoBlock();
2744 auto Abbv = std::make_shared<BitCodeAbbrev>();
2751 assert(
false &&
"Unexpected abbrev ordering!");
2755 auto Abbv = std::make_shared<BitCodeAbbrev>();
2762 assert(
false &&
"Unexpected abbrev ordering!");
2765 auto Abbv = std::make_shared<BitCodeAbbrev>();
2772 assert(
false &&
"Unexpected abbrev ordering!");
2775 auto Abbv = std::make_shared<BitCodeAbbrev>();
2781 std::move(Abbv)) != VST_BBENTRY_6_ABBREV)
2782 assert(
false &&
"Unexpected abbrev ordering!");
2786 auto Abbv = std::make_shared<BitCodeAbbrev>();
2791 CONSTANTS_SETTYPE_ABBREV)
2792 assert(
false &&
"Unexpected abbrev ordering!");
2796 auto Abbv = std::make_shared<BitCodeAbbrev>();
2800 CONSTANTS_INTEGER_ABBREV)
2801 assert(
false &&
"Unexpected abbrev ordering!");
2805 auto Abbv = std::make_shared<BitCodeAbbrev>();
2813 CONSTANTS_CE_CAST_Abbrev)
2814 assert(
false &&
"Unexpected abbrev ordering!");
2817 auto Abbv = std::make_shared<BitCodeAbbrev>();
2820 CONSTANTS_NULL_Abbrev)
2821 assert(
false &&
"Unexpected abbrev ordering!");
2827 auto Abbv = std::make_shared<BitCodeAbbrev>();
2835 (
unsigned)FUNCTION_INST_LOAD_ABBREV)
2836 assert(
false &&
"Unexpected abbrev ordering!");
2839 auto Abbv = std::make_shared<BitCodeAbbrev>();
2845 (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2846 assert(
false &&
"Unexpected abbrev ordering!");
2849 auto Abbv = std::make_shared<BitCodeAbbrev>();
2856 (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV)
2857 assert(
false &&
"Unexpected abbrev ordering!");
2860 auto Abbv = std::make_shared<BitCodeAbbrev>();
2867 (
unsigned)FUNCTION_INST_CAST_ABBREV)
2868 assert(
false &&
"Unexpected abbrev ordering!");
2872 auto Abbv = std::make_shared<BitCodeAbbrev>();
2875 (
unsigned)FUNCTION_INST_RET_VOID_ABBREV)
2876 assert(
false &&
"Unexpected abbrev ordering!");
2879 auto Abbv = std::make_shared<BitCodeAbbrev>();
2883 (
unsigned)FUNCTION_INST_RET_VAL_ABBREV)
2884 assert(
false &&
"Unexpected abbrev ordering!");
2887 auto Abbv = std::make_shared<BitCodeAbbrev>();
2890 (
unsigned)FUNCTION_INST_UNREACHABLE_ABBREV)
2891 assert(
false &&
"Unexpected abbrev ordering!");
2894 auto Abbv = std::make_shared<BitCodeAbbrev>();
2902 (
unsigned)FUNCTION_INST_GEP_ABBREV)
2903 assert(
false &&
"Unexpected abbrev ordering!");
2909 void DXILBitcodeWriter::writeModuleVersion() {
2924 DXILBitcodeWriter::writeModuleVersion();
2930 writeAttributeGroupTable();
2933 writeAttributeTable();
2945 writeModuleConstants();
2948 writeModuleMetadataKinds();
2951 writeModuleMetadata();
2956 writeFunctionLevelValueSymbolTable(
M.getValueSymbolTable());
2959 writeUseListBlock(
nullptr);
2963 if (!
F.isDeclaration())