60#define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
61#include "llvm/IR/Metadata.def"
79 CONSTANTS_INTEGER_ABBREV,
80 CONSTANTS_CE_CAST_Abbrev,
81 CONSTANTS_NULL_Abbrev,
85 FUNCTION_INST_BINOP_ABBREV,
86 FUNCTION_INST_BINOP_FLAGS_ABBREV,
87 FUNCTION_INST_CAST_ABBREV,
88 FUNCTION_INST_RET_VOID_ABBREV,
89 FUNCTION_INST_RET_VAL_ABBREV,
90 FUNCTION_INST_UNREACHABLE_ABBREV,
91 FUNCTION_INST_GEP_ABBREV,
112 std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap;
115 unsigned GlobalValueId;
135 : I8Ty(
Type::getInt8Ty(M.getContext())),
137 StrtabBuilder(StrtabBuilder), M(M), VE(M, I8PtrTy), Buffer(Buffer),
138 BitcodeStartBit(Stream.GetCurrentBitNo()),
139 PointerMap(PointerTypeAnalysis::run(M)) {
142 for (
auto El : PointerMap)
170 void writeModuleVersion();
171 void writePerModuleGlobalValueSummary();
176 unsigned FSCallsAbbrev,
177 unsigned FSCallsProfileAbbrev,
181 unsigned FSModRefsAbbrev,
182 unsigned FSModVTableRefsAbbrev);
185 GUIDToValueIdMap[ValGUID] = ++GlobalValueId;
189 const auto &VMI = GUIDToValueIdMap.find(ValGUID);
192 assert(VMI != GUIDToValueIdMap.end() &&
193 "GUID does not have assigned value Id");
199 if (!VI.haveGVs() || !VI.getValue())
200 return getValueId(VI.getGUID());
204 std::map<GlobalValue::GUID, unsigned> &valueIds() {
return GUIDToValueIdMap; }
206 uint64_t bitcodeStartBit() {
return BitcodeStartBit; }
210 unsigned createDILocationAbbrev();
211 unsigned createGenericDINodeAbbrev();
213 void writeAttributeGroupTable();
214 void writeAttributeTable();
215 void writeTypeTable();
217 void writeValueSymbolTableForwardDecl();
218 void writeModuleInfo();
316 unsigned createNamedMetadataAbbrev();
318 unsigned createMetadataStringsAbbrev();
323 std::vector<unsigned> *MDAbbrevs =
nullptr,
324 std::vector<uint64_t> *IndexPos =
nullptr);
325 void writeModuleMetadata();
326 void writeFunctionMetadata(
const Function &
F);
327 void writeFunctionMetadataAttachment(
const Function &
F);
330 void writeModuleMetadataKinds();
331 void writeOperandBundleTags();
332 void writeSyncScopeNames();
333 void writeConstants(
unsigned FirstVal,
unsigned LastVal,
bool isGlobal);
334 void writeModuleConstants();
335 bool pushValueAndType(
const Value *V,
unsigned InstID,
337 void writeOperandBundles(
const CallBase &CB,
unsigned InstID);
338 void pushValue(
const Value *V,
unsigned InstID,
340 void pushValueSigned(
const Value *V,
unsigned InstID,
342 void writeInstruction(
const Instruction &
I,
unsigned InstID,
345 void writeGlobalValueSymbolTable(
348 void writeBlockInfo();
352 unsigned getEncodedAlign(
MaybeAlign Alignment) {
return encode(Alignment); }
354 unsigned getTypeID(
Type *
T,
const Value *V =
nullptr);
376 Stream->
Emit((
unsigned)
'B', 8);
377 Stream->
Emit((
unsigned)
'C', 8);
378 Stream->
Emit(0x0, 4);
379 Stream->
Emit(0xC, 4);
380 Stream->
Emit(0xE, 4);
381 Stream->
Emit(0xD, 4);
393 Triple TT(M.getTargetTriple());
394 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
408 auto Abbv = std::make_shared<BitCodeAbbrev>();
411 auto AbbrevNo = Stream->
EmitAbbrev(std::move(Abbv));
424 assert(M.isMaterialized());
425 Mods.push_back(
const_cast<Module *
>(&M));
428 ModuleWriter.
write();
439 case Instruction::Trunc:
441 case Instruction::ZExt:
443 case Instruction::SExt:
445 case Instruction::FPToUI:
447 case Instruction::FPToSI:
449 case Instruction::UIToFP:
451 case Instruction::SIToFP:
453 case Instruction::FPTrunc:
455 case Instruction::FPExt:
457 case Instruction::PtrToInt:
459 case Instruction::IntToPtr:
461 case Instruction::BitCast:
463 case Instruction::AddrSpaceCast:
472 case Instruction::FNeg:
481 case Instruction::Add:
482 case Instruction::FAdd:
484 case Instruction::Sub:
485 case Instruction::FSub:
487 case Instruction::Mul:
488 case Instruction::FMul:
490 case Instruction::UDiv:
492 case Instruction::FDiv:
493 case Instruction::SDiv:
495 case Instruction::URem:
497 case Instruction::FRem:
498 case Instruction::SRem:
500 case Instruction::Shl:
502 case Instruction::LShr:
504 case Instruction::AShr:
506 case Instruction::And:
508 case Instruction::Or:
510 case Instruction::Xor:
515unsigned DXILBitcodeWriter::getTypeID(
Type *
T,
const Value *V) {
516 if (!
T->isPointerTy() &&
519 (!V || !isa<Constant>(V)))
521 auto It = PointerMap.
find(V);
522 if (It != PointerMap.
end())
528 if (V && isa<Constant>(V) && !isa<ConstantPointerNull>(V))
533unsigned DXILBitcodeWriter::getGlobalObjectValueTypeID(
Type *
T,
535 auto It = PointerMap.
find(
G);
536 if (It != PointerMap.
end()) {
602 unsigned AbbrevToUse) {
618 case Attribute::Alignment:
620 case Attribute::AlwaysInline:
622 case Attribute::Builtin:
624 case Attribute::ByVal:
626 case Attribute::Convergent:
628 case Attribute::InAlloca:
630 case Attribute::Cold:
632 case Attribute::InlineHint:
634 case Attribute::InReg:
636 case Attribute::JumpTable:
638 case Attribute::MinSize:
640 case Attribute::Naked:
642 case Attribute::Nest:
644 case Attribute::NoAlias:
646 case Attribute::NoBuiltin:
648 case Attribute::NoCapture:
650 case Attribute::NoDuplicate:
652 case Attribute::NoImplicitFloat:
654 case Attribute::NoInline:
656 case Attribute::NonLazyBind:
658 case Attribute::NonNull:
660 case Attribute::Dereferenceable:
662 case Attribute::DereferenceableOrNull:
664 case Attribute::NoRedZone:
666 case Attribute::NoReturn:
668 case Attribute::NoUnwind:
670 case Attribute::OptimizeForSize:
672 case Attribute::OptimizeNone:
674 case Attribute::ReadNone:
676 case Attribute::ReadOnly:
678 case Attribute::Returned:
680 case Attribute::ReturnsTwice:
682 case Attribute::SExt:
684 case Attribute::StackAlignment:
686 case Attribute::StackProtect:
688 case Attribute::StackProtectReq:
690 case Attribute::StackProtectStrong:
692 case Attribute::SafeStack:
694 case Attribute::StructRet:
696 case Attribute::SanitizeAddress:
698 case Attribute::SanitizeThread:
700 case Attribute::SanitizeMemory:
702 case Attribute::UWTable:
704 case Attribute::ZExt:
715 "should be stripped in DXILPrepare");
735 unsigned NumWords =
A.getActiveWords();
736 const uint64_t *RawData =
A.getRawData();
737 for (
unsigned i = 0; i < NumWords; i++)
744 if (
const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
745 if (OBO->hasNoSignedWrap())
747 if (OBO->hasNoUnsignedWrap())
749 }
else if (
const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
752 }
else if (
const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
753 if (FPMO->hasAllowReassoc())
755 if (FPMO->hasNoNaNs())
757 if (FPMO->hasNoInfs())
759 if (FPMO->hasNoSignedZeros())
761 if (FPMO->hasAllowReciprocal())
763 if (FPMO->hasAllowContract())
765 if (FPMO->hasApproxFunc())
846 switch (
C.getSelectionKind()) {
865void DXILBitcodeWriter::writeAttributeGroupTable() {
866 const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
868 if (AttrGrps.empty())
875 unsigned AttrListIndex = Pair.first;
878 Record.push_back(AttrListIndex);
881 if (Attr.isEnumAttribute()) {
884 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
887 }
else if (Attr.isIntAttribute()) {
888 if (Attr.getKindAsEnum() == Attribute::AttrKind::Memory) {
906 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
909 Record.push_back(Attr.getValueAsInt());
932void DXILBitcodeWriter::writeAttributeTable() {
941 for (
unsigned i :
AL.indexes()) {
955void DXILBitcodeWriter::writeTypeTable() {
964 auto Abbv = std::make_shared<BitCodeAbbrev>();
968 unsigned PtrAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
971 Abbv = std::make_shared<BitCodeAbbrev>();
976 unsigned FunctionAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
979 Abbv = std::make_shared<BitCodeAbbrev>();
984 unsigned StructAnonAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
987 Abbv = std::make_shared<BitCodeAbbrev>();
991 unsigned StructNameAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
994 Abbv = std::make_shared<BitCodeAbbrev>();
999 unsigned StructNamedAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1002 Abbv = std::make_shared<BitCodeAbbrev>();
1006 unsigned ArrayAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1014 for (
Type *
T : TypeList) {
1015 int AbbrevToUse = 0;
1018 switch (
T->getTypeID()) {
1068 AbbrevToUse = PtrAbbrev;
1079 "dxilOpaquePtrReservedName", StructNameAbbrev);
1087 TypeVals.
push_back(getTypeID(FT->getReturnType()));
1088 for (
Type *PTy : FT->params())
1090 AbbrevToUse = FunctionAbbrev;
1098 for (
Type *ElTy :
ST->elements())
1101 if (
ST->isLiteral()) {
1103 AbbrevToUse = StructAnonAbbrev;
1105 if (
ST->isOpaque()) {
1109 AbbrevToUse = StructNamedAbbrev;
1113 if (!
ST->getName().empty())
1123 TypeVals.
push_back(AT->getNumElements());
1124 TypeVals.
push_back(getTypeID(AT->getElementType()));
1125 AbbrevToUse = ArrayAbbrev;
1133 TypeVals.
push_back(VT->getElementCount().getKnownMinValue());
1134 TypeVals.
push_back(getTypeID(VT->getElementType()));
1140 Stream.
EmitRecord(Code, TypeVals, AbbrevToUse);
1147void DXILBitcodeWriter::writeComdats() {
1152 size_t Size =
C->getName().size();
1155 for (
char Chr :
C->getName())
1162void DXILBitcodeWriter::writeValueSymbolTableForwardDecl() {}
1167void DXILBitcodeWriter::writeModuleInfo() {
1169 if (!
M.getTargetTriple().empty())
1172 const std::string &
DL =
M.getDataLayoutStr();
1175 if (!
M.getModuleInlineAsm().empty())
1181 std::map<std::string, unsigned> SectionMap;
1182 std::map<std::string, unsigned> GCMap;
1184 unsigned MaxGlobalType = 0;
1185 const auto UpdateMaxAlignment = [&MaxAlignment](
const MaybeAlign A) {
1187 MaxAlignment = !MaxAlignment ? *
A : std::max(*MaxAlignment, *
A);
1190 UpdateMaxAlignment(GV.getAlign());
1193 MaxGlobalType = std::max(
1194 MaxGlobalType, getGlobalObjectValueTypeID(GV.getValueType(), &GV));
1195 if (GV.hasSection()) {
1197 unsigned &Entry = SectionMap[std::string(GV.getSection())];
1200 GV.getSection(), 0 );
1201 Entry = SectionMap.size();
1206 UpdateMaxAlignment(
F.getAlign());
1207 if (
F.hasSection()) {
1209 unsigned &Entry = SectionMap[std::string(
F.getSection())];
1213 Entry = SectionMap.size();
1218 unsigned &Entry = GCMap[
F.getGC()];
1222 Entry = GCMap.size();
1228 unsigned SimpleGVarAbbrev = 0;
1229 if (!
M.global_empty()) {
1232 auto Abbv = std::make_shared<BitCodeAbbrev>();
1244 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1248 if (SectionMap.empty())
1254 SimpleGVarAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1260 unsigned AbbrevToUse = 0;
1266 Vals.
push_back(getGlobalObjectValueTypeID(GV.getValueType(), &GV));
1268 GV.getType()->getAddressSpace() << 2 | 2 |
1269 (GV.isConstant() ? 1 : 0));
1272 GV.isDeclaration() ? 0 : (VE.
getValueID(GV.getInitializer()) + 1));
1274 Vals.
push_back(getEncodedAlign(GV.getAlign()));
1275 Vals.
push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1277 if (GV.isThreadLocal() ||
1280 GV.isExternallyInitialized() ||
1286 Vals.
push_back(GV.isExternallyInitialized());
1290 AbbrevToUse = SimpleGVarAbbrev;
1302 Vals.
push_back(getGlobalObjectValueTypeID(
F.getFunctionType(), &
F));
1307 Vals.
push_back(getEncodedAlign(
F.getAlign()));
1308 Vals.
push_back(
F.hasSection() ? SectionMap[std::string(
F.getSection())]
1314 F.hasPrologueData() ? (VE.
getValueID(
F.getPrologueData()) + 1) : 0);
1320 F.hasPersonalityFn() ? (VE.
getValueID(
F.getPersonalityFn()) + 1) : 0);
1322 unsigned AbbrevToUse = 0;
1337 unsigned AbbrevToUse = 0;
1343void DXILBitcodeWriter::writeValueAsMetadata(
1347 Type *Ty =
V->getType();
1348 if (
Function *
F = dyn_cast<Function>(V))
1352 Record.push_back(getTypeID(Ty));
1358void DXILBitcodeWriter::writeMDTuple(
const MDTuple *
N,
1361 for (
unsigned i = 0, e =
N->getNumOperands(); i != e; ++i) {
1363 assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1364 "Unexpected function-local metadata");
1373void DXILBitcodeWriter::writeDILocation(
const DILocation *
N,
1377 Abbrev = createDILocationAbbrev();
1378 Record.push_back(
N->isDistinct());
1379 Record.push_back(
N->getLine());
1380 Record.push_back(
N->getColumn());
1391 return I < 0 ? ~(U << 1) : U << 1;
1394void DXILBitcodeWriter::writeDISubrange(
const DISubrange *
N,
1397 Record.push_back(
N->isDistinct());
1402 assert(Count &&
"Count is missing or not ConstantInt");
1406 DISubrange::BoundType LowerBound =
N->getLowerBound();
1408 "Lower bound provided but not ConstantInt");
1416void DXILBitcodeWriter::writeDIEnumerator(
const DIEnumerator *
N,
1419 Record.push_back(
N->isDistinct());
1427void DXILBitcodeWriter::writeDIBasicType(
const DIBasicType *
N,
1430 Record.push_back(
N->isDistinct());
1431 Record.push_back(
N->getTag());
1433 Record.push_back(
N->getSizeInBits());
1434 Record.push_back(
N->getAlignInBits());
1435 Record.push_back(
N->getEncoding());
1441void DXILBitcodeWriter::writeDIDerivedType(
const DIDerivedType *
N,
1444 Record.push_back(
N->isDistinct());
1445 Record.push_back(
N->getTag());
1448 Record.push_back(
N->getLine());
1451 Record.push_back(
N->getSizeInBits());
1452 Record.push_back(
N->getAlignInBits());
1453 Record.push_back(
N->getOffsetInBits());
1454 Record.push_back(
N->getFlags());
1464 Record.push_back(
N->isDistinct());
1465 Record.push_back(
N->getTag());
1468 Record.push_back(
N->getLine());
1471 Record.push_back(
N->getSizeInBits());
1472 Record.push_back(
N->getAlignInBits());
1473 Record.push_back(
N->getOffsetInBits());
1474 Record.push_back(
N->getFlags());
1476 Record.push_back(
N->getRuntimeLang());
1488 Record.push_back(
N->isDistinct());
1489 Record.push_back(
N->getFlags());
1496void DXILBitcodeWriter::writeDIFile(
const DIFile *
N,
1499 Record.push_back(
N->isDistinct());
1507void DXILBitcodeWriter::writeDICompileUnit(
const DICompileUnit *
N,
1510 Record.push_back(
N->isDistinct());
1511 Record.push_back(
N->getSourceLanguage());
1514 Record.push_back(
N->isOptimized());
1516 Record.push_back(
N->getRuntimeVersion());
1518 Record.push_back(
N->getEmissionKind());
1524 Record.push_back(
N->getDWOId());
1530void DXILBitcodeWriter::writeDISubprogram(
const DISubprogram *
N,
1533 Record.push_back(
N->isDistinct());
1538 Record.push_back(
N->getLine());
1540 Record.push_back(
N->isLocalToUnit());
1541 Record.push_back(
N->isDefinition());
1542 Record.push_back(
N->getScopeLine());
1544 Record.push_back(
N->getVirtuality());
1545 Record.push_back(
N->getVirtualIndex());
1546 Record.push_back(
N->getFlags());
1547 Record.push_back(
N->isOptimized());
1560 Record.push_back(
N->isDistinct());
1563 Record.push_back(
N->getLine());
1564 Record.push_back(
N->getColumn());
1570void DXILBitcodeWriter::writeDILexicalBlockFile(
1573 Record.push_back(
N->isDistinct());
1576 Record.push_back(
N->getDiscriminator());
1582void DXILBitcodeWriter::writeDINamespace(
const DINamespace *
N,
1585 Record.push_back(
N->isDistinct());
1595void DXILBitcodeWriter::writeDIModule(
const DIModule *
N,
1598 Record.push_back(
N->isDistinct());
1599 for (
auto &
I :
N->operands())
1606void DXILBitcodeWriter::writeDITemplateTypeParameter(
1609 Record.push_back(
N->isDistinct());
1617void DXILBitcodeWriter::writeDITemplateValueParameter(
1620 Record.push_back(
N->isDistinct());
1621 Record.push_back(
N->getTag());
1633 Record.push_back(
N->isDistinct());
1638 Record.push_back(
N->getLine());
1640 Record.push_back(
N->isLocalToUnit());
1641 Record.push_back(
N->isDefinition());
1652 Record.push_back(
N->isDistinct());
1653 Record.push_back(
N->getTag());
1657 Record.push_back(
N->getLine());
1659 Record.push_back(
N->getArg());
1660 Record.push_back(
N->getFlags());
1666void DXILBitcodeWriter::writeDIExpression(
const DIExpression *
N,
1669 Record.reserve(
N->getElements().size() + 1);
1671 Record.push_back(
N->isDistinct());
1672 Record.append(
N->elements_begin(),
N->elements_end());
1687 Record.push_back(
N->isDistinct());
1688 Record.push_back(
N->getTag());
1691 Record.push_back(
N->getLine());
1698unsigned DXILBitcodeWriter::createDILocationAbbrev() {
1703 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1713unsigned DXILBitcodeWriter::createGenericDINodeAbbrev() {
1718 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1731 std::vector<unsigned> *MDAbbrevs,
1732 std::vector<uint64_t> *IndexPos) {
1737#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
1738#include "llvm/IR/Metadata.def"
1743 if (
const MDNode *
N = dyn_cast<MDNode>(MD)) {
1744 assert(
N->isResolved() &&
"Expected forward references to be resolved");
1746 switch (
N->getMetadataID()) {
1749#define HANDLE_MDNODE_LEAF(CLASS) \
1750 case Metadata::CLASS##Kind: \
1752 write##CLASS(cast<CLASS>(N), Record, \
1753 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
1755 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
1757#include "llvm/IR/Metadata.def"
1760 writeValueAsMetadata(cast<ValueAsMetadata>(MD),
Record);
1764unsigned DXILBitcodeWriter::createMetadataStringsAbbrev() {
1765 auto Abbv = std::make_shared<BitCodeAbbrev>();
1772void DXILBitcodeWriter::writeMetadataStrings(
1774 if (Strings.empty())
1777 unsigned MDSAbbrev = createMetadataStringsAbbrev();
1779 for (
const Metadata *MD : Strings) {
1780 const MDString *MDS = cast<MDString>(MD);
1790void DXILBitcodeWriter::writeModuleMetadata() {
1791 if (!VE.
hasMDs() &&
M.named_metadata_empty())
1798 std::vector<unsigned> MDAbbrevs;
1801 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
1802 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
1803 createGenericDINodeAbbrev();
1805 unsigned NameAbbrev = 0;
1806 if (!
M.named_metadata_empty()) {
1808 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1812 NameAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1818 std::vector<uint64_t> IndexPos;
1826 Record.append(Str.bytes_begin(), Str.bytes_end());
1831 for (
const MDNode *
N : NMD.operands())
1840void DXILBitcodeWriter::writeFunctionMetadata(
const Function &
F) {
1851void DXILBitcodeWriter::writeFunctionMetadataAttachment(
const Function &
F) {
1859 F.getAllMetadata(MDs);
1861 for (
const auto &
I : MDs) {
1872 I.getAllMetadataOtherThanDebugLoc(MDs);
1880 for (
unsigned i = 0, e = MDs.size(); i != e; ++i) {
1881 Record.push_back(MDs[i].first);
1891void DXILBitcodeWriter::writeModuleMetadataKinds() {
1897 M.getMDKindNames(Names);
1904 for (
unsigned MDKindID = 0, e = Names.
size(); MDKindID != e; ++MDKindID) {
1905 Record.push_back(MDKindID);
1916void DXILBitcodeWriter::writeConstants(
unsigned FirstVal,
unsigned LastVal,
1918 if (FirstVal == LastVal)
1923 unsigned AggregateAbbrev = 0;
1924 unsigned String8Abbrev = 0;
1925 unsigned CString7Abbrev = 0;
1926 unsigned CString6Abbrev = 0;
1930 auto Abbv = std::make_shared<BitCodeAbbrev>();
1935 AggregateAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1938 Abbv = std::make_shared<BitCodeAbbrev>();
1942 String8Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1944 Abbv = std::make_shared<BitCodeAbbrev>();
1948 CString7Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1950 Abbv = std::make_shared<BitCodeAbbrev>();
1954 CString6Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1960 Type *LastTy =
nullptr;
1961 for (
unsigned i = FirstVal; i != LastVal; ++i) {
1962 const Value *
V = Vals[i].first;
1964 if (
V->getType() != LastTy) {
1965 LastTy =
V->getType();
1966 Record.push_back(getTypeID(LastTy, V));
1968 CONSTANTS_SETTYPE_ABBREV);
1972 if (
const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
1973 Record.push_back(
unsigned(
IA->hasSideEffects()) |
1974 unsigned(
IA->isAlignStack()) << 1 |
1975 unsigned(
IA->getDialect() & 1) << 2);
1978 const std::string &AsmStr =
IA->getAsmString();
1979 Record.push_back(AsmStr.size());
1980 Record.append(AsmStr.begin(), AsmStr.end());
1983 const std::string &ConstraintStr =
IA->getConstraintString();
1984 Record.push_back(ConstraintStr.size());
1985 Record.append(ConstraintStr.begin(), ConstraintStr.end());
1991 unsigned Code = -1U;
1992 unsigned AbbrevToUse = 0;
1993 if (
C->isNullValue()) {
1995 }
else if (isa<UndefValue>(
C)) {
1998 if (
IV->getBitWidth() <= 64) {
2002 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2008 unsigned NWords =
IV->getValue().getActiveWords();
2009 const uint64_t *RawWords =
IV->getValue().getRawData();
2010 for (
unsigned i = 0; i != NWords; ++i) {
2015 }
else if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(
C)) {
2017 Type *Ty = CFP->getType();
2019 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2023 APInt api = CFP->getValueAPF().bitcastToAPInt();
2025 Record.push_back((p[1] << 48) | (p[0] >> 16));
2026 Record.push_back(p[0] & 0xffffLL);
2028 APInt api = CFP->getValueAPF().bitcastToAPInt();
2033 assert(0 &&
"Unknown FP type!");
2035 }
else if (isa<ConstantDataSequential>(
C) &&
2036 cast<ConstantDataSequential>(
C)->isString()) {
2039 unsigned NumElts = Str->getNumElements();
2041 if (Str->isCString()) {
2046 AbbrevToUse = String8Abbrev;
2050 for (
unsigned i = 0; i != NumElts; ++i) {
2051 unsigned char V = Str->getElementAsInteger(i);
2053 isCStr7 &= (
V & 128) == 0;
2059 AbbrevToUse = CString6Abbrev;
2061 AbbrevToUse = CString7Abbrev;
2063 dyn_cast<ConstantDataSequential>(
C)) {
2065 Type *EltTy = CDS->getElementType();
2066 if (isa<IntegerType>(EltTy)) {
2067 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
2068 Record.push_back(CDS->getElementAsInteger(i));
2070 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
2075 F = CDS->getElementAsFloat(i);
2080 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
2085 F = CDS->getElementAsDouble(i);
2089 }
else if (isa<ConstantArray>(
C) || isa<ConstantStruct>(
C) ||
2090 isa<ConstantVector>(
C)) {
2092 for (
const Value *
Op :
C->operands())
2094 AbbrevToUse = AggregateAbbrev;
2095 }
else if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(
C)) {
2096 switch (
CE->getOpcode()) {
2102 getTypeID(
C->getOperand(0)->getType(),
C->getOperand(0)));
2104 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2106 assert(
CE->getNumOperands() == 2 &&
"Unknown constant expr!");
2116 case Instruction::GetElementPtr: {
2118 const auto *GO = cast<GEPOperator>(
C);
2119 if (GO->isInBounds())
2121 Record.push_back(getTypeID(GO->getSourceElementType()));
2122 for (
unsigned i = 0, e =
CE->getNumOperands(); i != e; ++i) {
2124 getTypeID(
C->getOperand(i)->getType(),
C->getOperand(i)));
2129 case Instruction::Select:
2135 case Instruction::ExtractElement:
2137 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2139 Record.push_back(getTypeID(
C->getOperand(1)->getType()));
2142 case Instruction::InsertElement:
2146 Record.push_back(getTypeID(
C->getOperand(2)->getType()));
2149 case Instruction::ShuffleVector:
2154 if (
C->getType() ==
C->getOperand(0)->getType()) {
2158 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2164 case Instruction::ICmp:
2165 case Instruction::FCmp:
2167 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2170 Record.push_back(
CE->getPredicate());
2173 }
else if (
const BlockAddress *BA = dyn_cast<BlockAddress>(
C)) {
2175 Record.push_back(getTypeID(BA->getFunction()->getType()));
2191void DXILBitcodeWriter::writeModuleConstants() {
2196 for (
unsigned i = 0, e = Vals.size(); i != e; ++i) {
2197 if (!isa<GlobalValue>(Vals[i].first)) {
2198 writeConstants(i, Vals.size(),
true);
2212bool DXILBitcodeWriter::pushValueAndType(
const Value *V,
unsigned InstID,
2217 if (
ValID >= InstID) {
2226void DXILBitcodeWriter::pushValue(
const Value *V,
unsigned InstID,
2232void DXILBitcodeWriter::pushValueSigned(
const Value *V,
unsigned InstID,
2235 int64_t diff = ((int32_t)InstID - (int32_t)
ValID);
2240void DXILBitcodeWriter::writeInstruction(
const Instruction &
I,
unsigned InstID,
2243 unsigned AbbrevToUse = 0;
2245 switch (
I.getOpcode()) {
2249 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2250 AbbrevToUse = (
unsigned)FUNCTION_INST_CAST_ABBREV;
2254 assert(isa<BinaryOperator>(
I) &&
"Unknown instruction!");
2256 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2257 AbbrevToUse = (
unsigned)FUNCTION_INST_BINOP_ABBREV;
2258 pushValue(
I.getOperand(1), InstID, Vals);
2262 if (AbbrevToUse == (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2263 AbbrevToUse = (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV;
2269 case Instruction::GetElementPtr: {
2271 AbbrevToUse = (
unsigned)FUNCTION_INST_GEP_ABBREV;
2272 auto &GEPInst = cast<GetElementPtrInst>(
I);
2274 Vals.
push_back(getTypeID(GEPInst.getSourceElementType()));
2275 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i)
2276 pushValueAndType(
I.getOperand(i), InstID, Vals);
2279 case Instruction::ExtractValue: {
2281 pushValueAndType(
I.getOperand(0), InstID, Vals);
2286 case Instruction::InsertValue: {
2288 pushValueAndType(
I.getOperand(0), InstID, Vals);
2289 pushValueAndType(
I.getOperand(1), InstID, Vals);
2294 case Instruction::Select:
2296 pushValueAndType(
I.getOperand(1), InstID, Vals);
2297 pushValue(
I.getOperand(2), InstID, Vals);
2298 pushValueAndType(
I.getOperand(0), InstID, Vals);
2300 case Instruction::ExtractElement:
2302 pushValueAndType(
I.getOperand(0), InstID, Vals);
2303 pushValueAndType(
I.getOperand(1), InstID, Vals);
2305 case Instruction::InsertElement:
2307 pushValueAndType(
I.getOperand(0), InstID, Vals);
2308 pushValue(
I.getOperand(1), InstID, Vals);
2309 pushValueAndType(
I.getOperand(2), InstID, Vals);
2311 case Instruction::ShuffleVector:
2313 pushValueAndType(
I.getOperand(0), InstID, Vals);
2314 pushValue(
I.getOperand(1), InstID, Vals);
2315 pushValue(cast<ShuffleVectorInst>(&
I)->getShuffleMaskForBitcode(), InstID,
2318 case Instruction::ICmp:
2319 case Instruction::FCmp: {
2322 pushValueAndType(
I.getOperand(0), InstID, Vals);
2323 pushValue(
I.getOperand(1), InstID, Vals);
2331 case Instruction::Ret: {
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()) {
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: {
2384 pushValueAndType(Callee, InstID, Vals);
2387 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2388 pushValue(
I.getOperand(i), InstID, Vals);
2391 if (FTy->isVarArg()) {
2392 for (
unsigned i = FTy->getNumParams(), e =
I.getNumOperands() - 3; i != e;
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);
2420 Stream.
EmitRecord(Code, Vals64, AbbrevToUse);
2425 case Instruction::LandingPad: {
2436 pushValueAndType(LP.
getClause(
I), InstID, Vals);
2441 case Instruction::Alloca: {
2445 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2448 assert(AlignRecord < 1 << 5 &&
"alignment greater than 1 << 64");
2450 AlignRecord |= 1 << 6;
2455 case Instruction::Load:
2456 if (cast<LoadInst>(
I).isAtomic()) {
2458 pushValueAndType(
I.getOperand(0), InstID, Vals);
2461 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2462 AbbrevToUse = (
unsigned)FUNCTION_INST_LOAD_ABBREV;
2466 Vals.
push_back(cast<LoadInst>(
I).isVolatile());
2467 if (cast<LoadInst>(
I).isAtomic()) {
2469 Vals.
push_back(getEncodedSyncScopeID(cast<LoadInst>(
I).getSyncScopeID()));
2472 case Instruction::Store:
2473 if (cast<StoreInst>(
I).isAtomic())
2477 pushValueAndType(
I.getOperand(1), InstID, Vals);
2478 pushValueAndType(
I.getOperand(0), InstID, Vals);
2480 Vals.
push_back(cast<StoreInst>(
I).isVolatile());
2481 if (cast<StoreInst>(
I).isAtomic()) {
2484 getEncodedSyncScopeID(cast<StoreInst>(
I).getSyncScopeID()));
2487 case Instruction::AtomicCmpXchg:
2489 pushValueAndType(
I.getOperand(0), InstID, Vals);
2490 pushValueAndType(
I.getOperand(1), InstID, Vals);
2491 pushValue(
I.getOperand(2), InstID, Vals);
2492 Vals.
push_back(cast<AtomicCmpXchgInst>(
I).isVolatile());
2496 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(
I).getSyncScopeID()));
2499 Vals.
push_back(cast<AtomicCmpXchgInst>(
I).isWeak());
2501 case Instruction::AtomicRMW:
2503 pushValueAndType(
I.getOperand(0), InstID, Vals);
2504 pushValue(
I.getOperand(1), InstID, Vals);
2507 Vals.
push_back(cast<AtomicRMWInst>(
I).isVolatile());
2510 getEncodedSyncScopeID(cast<AtomicRMWInst>(
I).getSyncScopeID()));
2512 case Instruction::Fence:
2515 Vals.
push_back(getEncodedSyncScopeID(cast<FenceInst>(
I).getSyncScopeID()));
2517 case Instruction::Call: {
2530 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
2532 if (FTy->getParamType(i)->isLabelTy())
2539 if (FTy->isVarArg()) {
2540 for (
unsigned i = FTy->getNumParams(), e = CI.
arg_size(); i != e; ++i)
2545 case Instruction::VAArg:
2547 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2548 pushValue(
I.getOperand(0), InstID, Vals);
2558void DXILBitcodeWriter::writeFunctionLevelValueSymbolTable(
2571 for (
auto &VI : VST) {
2576 return A->first() <
B->first();
2579 for (
const ValueName *SI : SortedTable) {
2584 bool isChar6 =
true;
2585 for (
const char *
C =
Name.getKeyData(), *E =
C +
Name.getKeyLength();
2589 if ((
unsigned char)*
C & 128) {
2595 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
2600 if (isa<BasicBlock>(
SI->getValue())) {
2603 AbbrevToUse = VST_BBENTRY_6_ABBREV;
2607 AbbrevToUse = VST_ENTRY_6_ABBREV;
2609 AbbrevToUse = VST_ENTRY_7_ABBREV;
2613 for (
const char *
P =
Name.getKeyData(),
2614 *E =
Name.getKeyData() +
Name.getKeyLength();
2619 Stream.
EmitRecord(Code, NameVals, AbbrevToUse);
2626void DXILBitcodeWriter::writeFunction(
const Function &
F) {
2639 unsigned CstStart, CstEnd;
2641 writeConstants(CstStart, CstEnd,
false);
2644 writeFunctionMetadata(
F);
2647 unsigned InstID = CstEnd;
2649 bool NeedsMetadataAttachment =
F.hasMetadata();
2657 writeInstruction(*
I, InstID, Vals);
2659 if (!
I->getType()->isVoidTy())
2663 NeedsMetadataAttachment |=
I->hasMetadataOtherThanDebugLoc();
2687 if (
auto *Symtab =
F.getValueSymbolTable())
2688 writeFunctionLevelValueSymbolTable(*Symtab);
2690 if (NeedsMetadataAttachment)
2691 writeFunctionMetadataAttachment(
F);
2698void DXILBitcodeWriter::writeBlockInfo() {
2705 auto Abbv = std::make_shared<BitCodeAbbrev>();
2711 std::move(Abbv)) != VST_ENTRY_8_ABBREV)
2712 assert(
false &&
"Unexpected abbrev ordering!");
2716 auto Abbv = std::make_shared<BitCodeAbbrev>();
2722 std::move(Abbv)) != VST_ENTRY_7_ABBREV)
2723 assert(
false &&
"Unexpected abbrev ordering!");
2726 auto Abbv = std::make_shared<BitCodeAbbrev>();
2732 std::move(Abbv)) != VST_ENTRY_6_ABBREV)
2733 assert(
false &&
"Unexpected abbrev ordering!");
2736 auto Abbv = std::make_shared<BitCodeAbbrev>();
2742 std::move(Abbv)) != VST_BBENTRY_6_ABBREV)
2743 assert(
false &&
"Unexpected abbrev ordering!");
2747 auto Abbv = std::make_shared<BitCodeAbbrev>();
2752 CONSTANTS_SETTYPE_ABBREV)
2753 assert(
false &&
"Unexpected abbrev ordering!");
2757 auto Abbv = std::make_shared<BitCodeAbbrev>();
2761 CONSTANTS_INTEGER_ABBREV)
2762 assert(
false &&
"Unexpected abbrev ordering!");
2766 auto Abbv = std::make_shared<BitCodeAbbrev>();
2774 CONSTANTS_CE_CAST_Abbrev)
2775 assert(
false &&
"Unexpected abbrev ordering!");
2778 auto Abbv = std::make_shared<BitCodeAbbrev>();
2781 CONSTANTS_NULL_Abbrev)
2782 assert(
false &&
"Unexpected abbrev ordering!");
2788 auto Abbv = std::make_shared<BitCodeAbbrev>();
2796 (
unsigned)FUNCTION_INST_LOAD_ABBREV)
2797 assert(
false &&
"Unexpected abbrev ordering!");
2800 auto Abbv = std::make_shared<BitCodeAbbrev>();
2806 (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2807 assert(
false &&
"Unexpected abbrev ordering!");
2810 auto Abbv = std::make_shared<BitCodeAbbrev>();
2817 (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV)
2818 assert(
false &&
"Unexpected abbrev ordering!");
2821 auto Abbv = std::make_shared<BitCodeAbbrev>();
2828 (
unsigned)FUNCTION_INST_CAST_ABBREV)
2829 assert(
false &&
"Unexpected abbrev ordering!");
2833 auto Abbv = std::make_shared<BitCodeAbbrev>();
2836 (
unsigned)FUNCTION_INST_RET_VOID_ABBREV)
2837 assert(
false &&
"Unexpected abbrev ordering!");
2840 auto Abbv = std::make_shared<BitCodeAbbrev>();
2844 (
unsigned)FUNCTION_INST_RET_VAL_ABBREV)
2845 assert(
false &&
"Unexpected abbrev ordering!");
2848 auto Abbv = std::make_shared<BitCodeAbbrev>();
2851 (
unsigned)FUNCTION_INST_UNREACHABLE_ABBREV)
2852 assert(
false &&
"Unexpected abbrev ordering!");
2855 auto Abbv = std::make_shared<BitCodeAbbrev>();
2863 (
unsigned)FUNCTION_INST_GEP_ABBREV)
2864 assert(
false &&
"Unexpected abbrev ordering!");
2870void DXILBitcodeWriter::writeModuleVersion() {
2885 DXILBitcodeWriter::writeModuleVersion();
2891 writeAttributeGroupTable();
2894 writeAttributeTable();
2906 writeModuleConstants();
2909 writeModuleMetadataKinds();
2912 writeModuleMetadata();
2917 writeFunctionLevelValueSymbolTable(M.getValueSymbolTable());
2921 if (!
F.isDeclaration())
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static uint64_t rotateSign(APInt Val)
This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
static const uint32_t IV[8]
Class for arbitrary precision integers.
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
int64_t getSExtValue() const
Get sign extended value.
an instruction to allocate memory on the stack
Align getAlign() const
Return the alignment of the memory that is being allocated by the instruction.
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
bool isUsedWithInAlloca() const
Return true if this alloca is used as an inalloca argument to a call.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool empty() const
empty - Check if the array is empty.
BinOp
This enumeration lists the possible modifications atomicrmw can make.
@ Min
*p = old <signed v ? old : v
@ Max
*p = old >signed v ? old : v
@ UMin
*p = old <unsigned v ? old : v
@ FMin
*p = minnum(old, v) minnum matches the behavior of llvm.minnum.
@ UMax
*p = old >unsigned v ? old : v
@ FMax
*p = maxnum(old, v) maxnum matches the behavior of llvm.maxnum.
bool hasAttributes() const
Return true if attributes exists in this set.
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
@ TombstoneKey
Use as Tombstone key for DenseMap of AttrKind.
@ None
No attributes have been set.
@ EmptyKey
Use as Empty key for DenseMap of AttrKind.
@ EndAttrKinds
Sentinel value useful for loops.
LLVM Basic Block Representation.
InstListType::const_iterator const_iterator
BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
static bool isChar6(char C)
isChar6 - Return true if this character is legal in the Char6 encoding.
unsigned EmitAbbrev(std::shared_ptr< BitCodeAbbrev > Abbv)
Emits the abbreviation Abbv to the stream.
void EmitRecord(unsigned Code, const Container &Vals, unsigned Abbrev=0)
EmitRecord - Emit the specified record to the stream, using an abbrev if we have one to compress the ...
void Emit(uint32_t Val, unsigned NumBits)
void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals, StringRef Blob)
EmitRecordWithBlob - Emit the specified record to the stream, using an abbrev that includes a blob at...
unsigned EmitBlockInfoAbbrev(unsigned BlockID, std::shared_ptr< BitCodeAbbrev > Abbv)
EmitBlockInfoAbbrev - Emit a DEFINE_ABBREV record for the specified BlockID.
void EnterBlockInfoBlock()
EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK.
void EnterSubblock(unsigned BlockID, unsigned CodeLen)
uint64_t GetCurrentBitNo() const
Retrieve the current position in the stream, in bits.
The address of a basic block.
Conditional or Unconditional Branch instruction.
bool isConditional() const
BasicBlock * getSuccessor(unsigned i) const
Value * getCondition() const
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
CallingConv::ID getCallingConv() const
Value * getCalledOperand() const
Value * getArgOperand(unsigned i) const
FunctionType * getFunctionType() const
unsigned arg_size() const
AttributeList getAttributes() const
Return the parameter attributes for this call.
This class represents a function call, abstracting a target machine's calling convention.
bool isMustTailCall() const
@ Largest
The linker will choose the largest COMDAT.
@ SameSize
The data referenced by the COMDAT must be the same size.
@ Any
The linker may choose any COMDAT.
@ NoDeduplicate
No deduplication is performed.
@ ExactMatch
The data referenced by the COMDAT must be the same.
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
A constant value that is initialized with an expression using other constant values.
ConstantFP - Floating Point Values [float, double].
This is the shared class of boolean and integer constants.
const APInt & getValue() const
Return the constant as an APInt value reference.
This is an important base class in LLVM.
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
Basic type, like 'int' or 'float'.
A pair of DIGlobalVariable and DIExpression.
An imported module (C++ using directive or similar).
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
String type, Fortran CHARACTER(n)
Type array for a subprogram.
This class represents an Operation in the Expression.
iterator find(const_arg_type_t< KeyT > Val)
BasicBlockListType::const_iterator const_iterator
Generic tagged DWARF-like metadata node.
Function and variable summary information to aid decisions and implementation of importing.
VisibilityTypes getVisibility() const
LinkageTypes getLinkage() const
ThreadLocalMode getThreadLocalMode() const
@ DLLExportStorageClass
Function to be accessible from DLL.
@ DLLImportStorageClass
Function to be imported from DLL.
@ DefaultVisibility
The GV is visible.
@ HiddenVisibility
The GV is hidden.
@ ProtectedVisibility
The GV is protected.
LinkageTypes
An enumeration for the kinds of linkage for global values.
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ CommonLinkage
Tentative definitions.
@ InternalLinkage
Rename collisions when linking (static functions).
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
@ WeakODRLinkage
Same, but only replaced by something equivalent.
@ ExternalLinkage
Externally visible function.
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
@ AppendingLinkage
Special purpose, only applies to global arrays.
@ AvailableExternallyLinkage
Available for inspection, not emission.
@ ExternalWeakLinkage
ExternalWeak linkage description.
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
DLLStorageClassTypes getDLLStorageClass() const
This instruction inserts a struct field of array element value into an aggregate value.
idx_iterator idx_end() const
idx_iterator idx_begin() const
BasicBlock * getUnwindDest() const
BasicBlock * getNormalDest() const
The landingpad instruction holds all of the information necessary to generate correct exception handl...
bool isCleanup() const
Return 'true' if this landingpad instruction is a cleanup.
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
bool isCatch(unsigned Idx) const
Return 'true' if the clause and index Idx is a catch clause.
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
const unsigned char * bytes_begin() const
const unsigned char * bytes_end() const
bool doesNotAccessMemory() const
Whether this function accesses no memory.
bool onlyAccessesArgPointees() const
Whether this function only (at most) accesses argument memory.
bool onlyReadsMemory() const
Whether this function only (at most) reads memory.
A Module instance is used to store all the information related to an LLVM module.
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
iterator insert(iterator I, T &&Elt)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
Utility for building string tables with deduplicated suffixes.
Class to represent struct types.
Triple - Helper class for working with autoconf configuration names.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isX86_FP80Ty() const
Return true if this is x86 long double.
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
@ X86_MMXTyID
MMX vectors (64 bits, X86 specific)
@ X86_AMXTyID
AMX vectors (8192 bits, X86 specific)
@ TypedPointerTyID
Typed pointer used by some GPU targets.
@ HalfTyID
16-bit floating point type
@ TargetExtTyID
Target extension type.
@ VoidTyID
type with no size
@ ScalableVectorTyID
Scalable SIMD vector type.
@ FloatTyID
32-bit floating point type
@ IntegerTyID
Arbitrary bit width integers.
@ FixedVectorTyID
Fixed width SIMD vector type.
@ BFloatTyID
16-bit floating point type (7-bit significand)
@ DoubleTyID
64-bit floating point type
@ X86_FP80TyID
80-bit floating point type (X87)
@ PPC_FP128TyID
128-bit floating point type (two 64-bits, PowerPC)
@ FP128TyID
128-bit floating point type (112-bit significand)
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
bool isFP128Ty() const
Return true if this is 'fp128'.
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
A few GPU targets, such as DXIL and SPIR-V, have typed pointers.
Type * getElementType() const
static TypedPointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
std::vector< std::pair< const Value *, unsigned > > ValueList
std::vector< Type * > TypeList
This class provides a symbol table of name/value pairs.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
BitcodeWriter(SmallVectorImpl< char > &Buffer, raw_fd_stream *FS=nullptr)
Create a BitcodeWriter that writes to Buffer.
void writeModule(const Module &M)
Write the specified module to the buffer specified at construction time.
static void emitWideAPInt(SmallVectorImpl< uint64_t > &Vals, const APInt &A)
static unsigned getEncodedThreadLocalMode(const GlobalValue &GV)
static unsigned getEncodedCastOpcode(unsigned Opcode)
Begin dxil::BitcodeWriterBase Implementation.
static void writeStringRecord(BitstreamWriter &Stream, unsigned Code, StringRef Str, unsigned AbbrevToUse)
static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind)
static unsigned getEncodedDLLStorageClass(const GlobalValue &GV)
static unsigned getEncodedOrdering(AtomicOrdering Ordering)
static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage)
static unsigned getEncodedVisibility(const GlobalValue &GV)
void write()
Emit the current module to the bitstream.
static void writeIdentificationBlock(BitstreamWriter &Stream)
static unsigned getEncodedBinaryOpcode(unsigned Opcode)
static void emitSignedInt64(SmallVectorImpl< uint64_t > &Vals, uint64_t V)
static unsigned getEncodedUnaryOpcode(unsigned Opcode)
static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op)
DXILBitcodeWriter(const Module &M, SmallVectorImpl< char > &Buffer, StringTableBuilder &StrtabBuilder, BitstreamWriter &Stream)
Constructs a ModuleBitcodeWriter object for the given Module, writing to the provided Buffer.
static unsigned getEncodedComdatSelectionKind(const Comdat &C)
static uint64_t getOptimizationFlags(const Value *V)
ArrayRef< const Metadata * > getNonMDStrings() const
Get the non-MDString metadata for this block.
unsigned getValueID(const Value *V) const
std::pair< unsigned, AttributeSet > IndexAndAttrSet
Attribute groups as encoded in bitcode are almost AttributeSets, but they include the AttributeList i...
void setInstructionID(const Instruction *I)
void EnumerateType(Type *T)
unsigned getMetadataOrNullID(const Metadata *MD) const
const std::vector< IndexAndAttrSet > & getAttributeGroups() const
unsigned getComdatID(const Comdat *C) const
ArrayRef< const Metadata * > getMDStrings() const
Get the MDString metadata for this block.
bool hasMDs() const
Check whether the current block has any metadata to emit.
uint64_t computeBitsRequiredForTypeIndices() const
const ComdatSetType & getComdats() const
unsigned getAttributeListID(AttributeList PAL) const
unsigned getMetadataID(const Metadata *MD) const
const TypeList & getTypes() const
const std::vector< AttributeList > & getAttributeLists() const
void incorporateFunction(const Function &F)
incorporateFunction/purgeFunction - If you'd like to deal with a function, use these two methods to g...
unsigned getTypeID(Type *T) const
unsigned getInstructionID(const Instruction *I) const
const ValueList & getValues() const
unsigned getGlobalBasicBlockID(const BasicBlock *BB) const
getGlobalBasicBlockID - This returns the function-specific ID for the specified basic block.
void getFunctionConstantRange(unsigned &Start, unsigned &End) const
getFunctionConstantRange - Return the range of values that corresponds to function-local constants.
const std::vector< const BasicBlock * > & getBasicBlocks() const
unsigned getAttributeGroupID(IndexAndAttrSet Group) const
A raw_ostream of a file for reading/writing/seeking.
This class implements an extremely fast bulk output stream that can only output to a stream.
raw_ostream & write(unsigned char C)
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
@ C
The default llvm calling convention, compatible with C.
Predicate getPredicate(unsigned Condition, unsigned Hint)
Return predicate consisting of specified condition and hint bits.
@ CE
Windows NT (Windows on ARM)
@ METADATA_TEMPLATE_VALUE
@ METADATA_LEXICAL_BLOCK_FILE
@ METADATA_SUBROUTINE_TYPE
@ METADATA_IMPORTED_ENTITY
@ METADATA_COMPOSITE_TYPE
@ CST_CODE_CE_INBOUNDS_GEP
@ COMDAT_SELECTION_KIND_LARGEST
@ COMDAT_SELECTION_KIND_ANY
@ COMDAT_SELECTION_KIND_SAME_SIZE
@ COMDAT_SELECTION_KIND_EXACT_MATCH
@ COMDAT_SELECTION_KIND_NO_DUPLICATES
@ ATTR_KIND_STACK_PROTECT
@ ATTR_KIND_STACK_PROTECT_STRONG
@ ATTR_KIND_SANITIZE_MEMORY
@ ATTR_KIND_OPTIMIZE_FOR_SIZE
@ ATTR_KIND_SANITIZE_ADDRESS
@ ATTR_KIND_NO_IMPLICIT_FLOAT
@ ATTR_KIND_STACK_ALIGNMENT
@ ATTR_KIND_STACK_PROTECT_REQ
@ ATTR_KIND_RETURNS_TWICE
@ ATTR_KIND_NON_LAZY_BIND
@ ATTR_KIND_DEREFERENCEABLE
@ ATTR_KIND_OPTIMIZE_NONE
@ ATTR_KIND_DEREFERENCEABLE_OR_NULL
@ ATTR_KIND_ALWAYS_INLINE
@ ATTR_KIND_SANITIZE_THREAD
@ PARAMATTR_GROUP_BLOCK_ID
@ MODULE_CODE_SECTIONNAME
@ FUNC_CODE_INST_LANDINGPAD
@ FUNC_CODE_INST_EXTRACTVAL
@ FUNC_CODE_INST_LOADATOMIC
@ FUNC_CODE_INST_STOREATOMIC
@ FUNC_CODE_INST_ATOMICRMW
@ FUNC_CODE_DEBUG_LOC_AGAIN
@ FUNC_CODE_INST_EXTRACTELT
@ FUNC_CODE_INST_INDIRECTBR
@ FUNC_CODE_INST_INSERTVAL
@ FUNC_CODE_DECLAREBLOCKS
@ FUNC_CODE_INST_INSERTELT
@ FUNC_CODE_INST_SHUFFLEVEC
@ FUNC_CODE_INST_UNREACHABLE
@ FIRST_APPLICATION_ABBREV
@ PARAMATTR_GRP_CODE_ENTRY
void WriteDXILToFile(const Module &M, raw_ostream &Out)
Write the specified module to the specified raw output stream.
NodeAddr< CodeNode * > Code
This is an optimization pass for GlobalISel generic memory operations.
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
unsigned encode(MaybeAlign A)
Returns a representation of the alignment that encodes undefined as 0.
MaybeAlign getAlign(const Function &F, unsigned Index)
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
void sort(IteratorTy Start, IteratorTy End)
AtomicOrdering
Atomic ordering for LLVM's memory model.
unsigned Log2(Align A)
Returns the log2 of the alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
ValID - Represents a reference of a definition of some sort with no type.
Struct that holds a reference to a particular GUID in a global value summary.