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);
375 Stream->
Emit((
unsigned)
'B', 8);
376 Stream->
Emit((
unsigned)
'C', 8);
377 Stream->
Emit(0x0, 4);
378 Stream->
Emit(0xC, 4);
379 Stream->
Emit(0xE, 4);
380 Stream->
Emit(0xD, 4);
392 Triple TT(M.getTargetTriple());
393 if (TT.isOSDarwin() || TT.isOSBinFormatMachO())
407 auto Abbv = std::make_shared<BitCodeAbbrev>();
410 auto AbbrevNo = Stream->
EmitAbbrev(std::move(Abbv));
423 assert(M.isMaterialized());
424 Mods.push_back(
const_cast<Module *
>(&M));
427 ModuleWriter.
write();
438 case Instruction::Trunc:
440 case Instruction::ZExt:
442 case Instruction::SExt:
444 case Instruction::FPToUI:
446 case Instruction::FPToSI:
448 case Instruction::UIToFP:
450 case Instruction::SIToFP:
452 case Instruction::FPTrunc:
454 case Instruction::FPExt:
456 case Instruction::PtrToInt:
458 case Instruction::IntToPtr:
460 case Instruction::BitCast:
462 case Instruction::AddrSpaceCast:
471 case Instruction::FNeg:
480 case Instruction::Add:
481 case Instruction::FAdd:
483 case Instruction::Sub:
484 case Instruction::FSub:
486 case Instruction::Mul:
487 case Instruction::FMul:
489 case Instruction::UDiv:
491 case Instruction::FDiv:
492 case Instruction::SDiv:
494 case Instruction::URem:
496 case Instruction::FRem:
497 case Instruction::SRem:
499 case Instruction::Shl:
501 case Instruction::LShr:
503 case Instruction::AShr:
505 case Instruction::And:
507 case Instruction::Or:
509 case Instruction::Xor:
514unsigned DXILBitcodeWriter::getTypeID(
Type *
T,
const Value *V) {
515 if (!
T->isPointerTy() &&
518 (!V || !isa<Constant>(V)))
520 auto It = PointerMap.
find(V);
521 if (It != PointerMap.
end())
527 if (V && isa<Constant>(V) && !isa<ConstantPointerNull>(V))
532unsigned DXILBitcodeWriter::getGlobalObjectValueTypeID(
Type *
T,
534 auto It = PointerMap.
find(
G);
535 if (It != PointerMap.
end()) {
601 unsigned AbbrevToUse) {
617 case Attribute::Alignment:
619 case Attribute::AlwaysInline:
621 case Attribute::Builtin:
623 case Attribute::ByVal:
625 case Attribute::Convergent:
627 case Attribute::InAlloca:
629 case Attribute::Cold:
631 case Attribute::InlineHint:
633 case Attribute::InReg:
635 case Attribute::JumpTable:
637 case Attribute::MinSize:
639 case Attribute::Naked:
641 case Attribute::Nest:
643 case Attribute::NoAlias:
645 case Attribute::NoBuiltin:
647 case Attribute::NoCapture:
649 case Attribute::NoDuplicate:
651 case Attribute::NoImplicitFloat:
653 case Attribute::NoInline:
655 case Attribute::NonLazyBind:
657 case Attribute::NonNull:
659 case Attribute::Dereferenceable:
661 case Attribute::DereferenceableOrNull:
663 case Attribute::NoRedZone:
665 case Attribute::NoReturn:
667 case Attribute::NoUnwind:
669 case Attribute::OptimizeForSize:
671 case Attribute::OptimizeNone:
673 case Attribute::ReadNone:
675 case Attribute::ReadOnly:
677 case Attribute::Returned:
679 case Attribute::ReturnsTwice:
681 case Attribute::SExt:
683 case Attribute::StackAlignment:
685 case Attribute::StackProtect:
687 case Attribute::StackProtectReq:
689 case Attribute::StackProtectStrong:
691 case Attribute::SafeStack:
693 case Attribute::StructRet:
695 case Attribute::SanitizeAddress:
697 case Attribute::SanitizeThread:
699 case Attribute::SanitizeMemory:
701 case Attribute::UWTable:
703 case Attribute::ZExt:
714 "should be stripped in DXILPrepare");
734 unsigned NumWords =
A.getActiveWords();
735 const uint64_t *RawData =
A.getRawData();
736 for (
unsigned i = 0; i < NumWords; i++)
743 if (
const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
744 if (OBO->hasNoSignedWrap())
746 if (OBO->hasNoUnsignedWrap())
748 }
else if (
const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
751 }
else if (
const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
752 if (FPMO->hasAllowReassoc())
754 if (FPMO->hasNoNaNs())
756 if (FPMO->hasNoInfs())
758 if (FPMO->hasNoSignedZeros())
760 if (FPMO->hasAllowReciprocal())
762 if (FPMO->hasAllowContract())
764 if (FPMO->hasApproxFunc())
845 switch (
C.getSelectionKind()) {
864void DXILBitcodeWriter::writeAttributeGroupTable() {
865 const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
867 if (AttrGrps.empty())
874 unsigned AttrListIndex = Pair.first;
877 Record.push_back(AttrListIndex);
880 if (Attr.isEnumAttribute()) {
883 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
886 }
else if (Attr.isIntAttribute()) {
887 if (Attr.getKindAsEnum() == Attribute::AttrKind::Memory) {
905 "DXIL does not support attributes above ATTR_KIND_ARGMEMONLY");
908 Record.push_back(Attr.getValueAsInt());
931void DXILBitcodeWriter::writeAttributeTable() {
940 for (
unsigned i :
AL.indexes()) {
954void DXILBitcodeWriter::writeTypeTable() {
963 auto Abbv = std::make_shared<BitCodeAbbrev>();
967 unsigned PtrAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
970 Abbv = std::make_shared<BitCodeAbbrev>();
975 unsigned FunctionAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
978 Abbv = std::make_shared<BitCodeAbbrev>();
983 unsigned StructAnonAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
986 Abbv = std::make_shared<BitCodeAbbrev>();
990 unsigned StructNameAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
993 Abbv = std::make_shared<BitCodeAbbrev>();
998 unsigned StructNamedAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1001 Abbv = std::make_shared<BitCodeAbbrev>();
1005 unsigned ArrayAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1013 for (
Type *
T : TypeList) {
1014 int AbbrevToUse = 0;
1017 switch (
T->getTypeID()) {
1064 AbbrevToUse = PtrAbbrev;
1075 "dxilOpaquePtrReservedName", StructNameAbbrev);
1083 TypeVals.
push_back(getTypeID(FT->getReturnType()));
1084 for (
Type *PTy : FT->params())
1086 AbbrevToUse = FunctionAbbrev;
1094 for (
Type *ElTy :
ST->elements())
1097 if (
ST->isLiteral()) {
1099 AbbrevToUse = StructAnonAbbrev;
1101 if (
ST->isOpaque()) {
1105 AbbrevToUse = StructNamedAbbrev;
1109 if (!
ST->getName().empty())
1119 TypeVals.
push_back(AT->getNumElements());
1120 TypeVals.
push_back(getTypeID(AT->getElementType()));
1121 AbbrevToUse = ArrayAbbrev;
1129 TypeVals.
push_back(VT->getElementCount().getKnownMinValue());
1130 TypeVals.
push_back(getTypeID(VT->getElementType()));
1136 Stream.
EmitRecord(Code, TypeVals, AbbrevToUse);
1143void DXILBitcodeWriter::writeComdats() {
1148 size_t Size =
C->getName().size();
1151 for (
char Chr :
C->getName())
1158void DXILBitcodeWriter::writeValueSymbolTableForwardDecl() {}
1163void DXILBitcodeWriter::writeModuleInfo() {
1165 if (!
M.getTargetTriple().empty())
1168 const std::string &
DL =
M.getDataLayoutStr();
1171 if (!
M.getModuleInlineAsm().empty())
1177 std::map<std::string, unsigned> SectionMap;
1178 std::map<std::string, unsigned> GCMap;
1180 unsigned MaxGlobalType = 0;
1181 const auto UpdateMaxAlignment = [&MaxAlignment](
const MaybeAlign A) {
1183 MaxAlignment = !MaxAlignment ? *
A : std::max(*MaxAlignment, *
A);
1186 UpdateMaxAlignment(GV.getAlign());
1189 MaxGlobalType = std::max(
1190 MaxGlobalType, getGlobalObjectValueTypeID(GV.getValueType(), &GV));
1191 if (GV.hasSection()) {
1193 unsigned &
Entry = SectionMap[std::string(GV.getSection())];
1196 GV.getSection(), 0 );
1197 Entry = SectionMap.size();
1202 UpdateMaxAlignment(
F.getAlign());
1203 if (
F.hasSection()) {
1205 unsigned &
Entry = SectionMap[std::string(
F.getSection())];
1209 Entry = SectionMap.size();
1214 unsigned &
Entry = GCMap[
F.getGC()];
1218 Entry = GCMap.size();
1224 unsigned SimpleGVarAbbrev = 0;
1225 if (!
M.global_empty()) {
1228 auto Abbv = std::make_shared<BitCodeAbbrev>();
1240 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1244 if (SectionMap.empty())
1250 SimpleGVarAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1256 unsigned AbbrevToUse = 0;
1262 Vals.
push_back(getGlobalObjectValueTypeID(GV.getValueType(), &GV));
1264 GV.getType()->getAddressSpace() << 2 | 2 |
1265 (GV.isConstant() ? 1 : 0));
1268 GV.isDeclaration() ? 0 : (VE.
getValueID(GV.getInitializer()) + 1));
1270 Vals.
push_back(getEncodedAlign(GV.getAlign()));
1271 Vals.
push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1273 if (GV.isThreadLocal() ||
1276 GV.isExternallyInitialized() ||
1282 Vals.
push_back(GV.isExternallyInitialized());
1286 AbbrevToUse = SimpleGVarAbbrev;
1298 Vals.
push_back(getGlobalObjectValueTypeID(
F.getFunctionType(), &
F));
1303 Vals.
push_back(getEncodedAlign(
F.getAlign()));
1304 Vals.
push_back(
F.hasSection() ? SectionMap[std::string(
F.getSection())]
1310 F.hasPrologueData() ? (VE.
getValueID(
F.getPrologueData()) + 1) : 0);
1316 F.hasPersonalityFn() ? (VE.
getValueID(
F.getPersonalityFn()) + 1) : 0);
1318 unsigned AbbrevToUse = 0;
1333 unsigned AbbrevToUse = 0;
1339void DXILBitcodeWriter::writeValueAsMetadata(
1343 Type *Ty =
V->getType();
1344 if (
Function *
F = dyn_cast<Function>(V))
1348 Record.push_back(getTypeID(Ty));
1354void DXILBitcodeWriter::writeMDTuple(
const MDTuple *
N,
1357 for (
unsigned i = 0, e =
N->getNumOperands(); i != e; ++i) {
1359 assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1360 "Unexpected function-local metadata");
1369void DXILBitcodeWriter::writeDILocation(
const DILocation *
N,
1373 Abbrev = createDILocationAbbrev();
1374 Record.push_back(
N->isDistinct());
1375 Record.push_back(
N->getLine());
1376 Record.push_back(
N->getColumn());
1387 return I < 0 ? ~(U << 1) : U << 1;
1390void DXILBitcodeWriter::writeDISubrange(
const DISubrange *
N,
1393 Record.push_back(
N->isDistinct());
1398 assert(Count &&
"Count is missing or not ConstantInt");
1402 DISubrange::BoundType LowerBound =
N->getLowerBound();
1404 "Lower bound provided but not ConstantInt");
1412void DXILBitcodeWriter::writeDIEnumerator(
const DIEnumerator *
N,
1415 Record.push_back(
N->isDistinct());
1423void DXILBitcodeWriter::writeDIBasicType(
const DIBasicType *
N,
1426 Record.push_back(
N->isDistinct());
1427 Record.push_back(
N->getTag());
1429 Record.push_back(
N->getSizeInBits());
1430 Record.push_back(
N->getAlignInBits());
1431 Record.push_back(
N->getEncoding());
1437void DXILBitcodeWriter::writeDIDerivedType(
const DIDerivedType *
N,
1440 Record.push_back(
N->isDistinct());
1441 Record.push_back(
N->getTag());
1444 Record.push_back(
N->getLine());
1447 Record.push_back(
N->getSizeInBits());
1448 Record.push_back(
N->getAlignInBits());
1449 Record.push_back(
N->getOffsetInBits());
1450 Record.push_back(
N->getFlags());
1460 Record.push_back(
N->isDistinct());
1461 Record.push_back(
N->getTag());
1464 Record.push_back(
N->getLine());
1467 Record.push_back(
N->getSizeInBits());
1468 Record.push_back(
N->getAlignInBits());
1469 Record.push_back(
N->getOffsetInBits());
1470 Record.push_back(
N->getFlags());
1472 Record.push_back(
N->getRuntimeLang());
1484 Record.push_back(
N->isDistinct());
1485 Record.push_back(
N->getFlags());
1492void DXILBitcodeWriter::writeDIFile(
const DIFile *
N,
1495 Record.push_back(
N->isDistinct());
1503void DXILBitcodeWriter::writeDICompileUnit(
const DICompileUnit *
N,
1506 Record.push_back(
N->isDistinct());
1507 Record.push_back(
N->getSourceLanguage());
1510 Record.push_back(
N->isOptimized());
1512 Record.push_back(
N->getRuntimeVersion());
1514 Record.push_back(
N->getEmissionKind());
1520 Record.push_back(
N->getDWOId());
1526void DXILBitcodeWriter::writeDISubprogram(
const DISubprogram *
N,
1529 Record.push_back(
N->isDistinct());
1534 Record.push_back(
N->getLine());
1536 Record.push_back(
N->isLocalToUnit());
1537 Record.push_back(
N->isDefinition());
1538 Record.push_back(
N->getScopeLine());
1540 Record.push_back(
N->getVirtuality());
1541 Record.push_back(
N->getVirtualIndex());
1542 Record.push_back(
N->getFlags());
1543 Record.push_back(
N->isOptimized());
1556 Record.push_back(
N->isDistinct());
1559 Record.push_back(
N->getLine());
1560 Record.push_back(
N->getColumn());
1566void DXILBitcodeWriter::writeDILexicalBlockFile(
1569 Record.push_back(
N->isDistinct());
1572 Record.push_back(
N->getDiscriminator());
1578void DXILBitcodeWriter::writeDINamespace(
const DINamespace *
N,
1581 Record.push_back(
N->isDistinct());
1591void DXILBitcodeWriter::writeDIModule(
const DIModule *
N,
1594 Record.push_back(
N->isDistinct());
1595 for (
auto &
I :
N->operands())
1602void DXILBitcodeWriter::writeDITemplateTypeParameter(
1605 Record.push_back(
N->isDistinct());
1613void DXILBitcodeWriter::writeDITemplateValueParameter(
1616 Record.push_back(
N->isDistinct());
1617 Record.push_back(
N->getTag());
1629 Record.push_back(
N->isDistinct());
1634 Record.push_back(
N->getLine());
1636 Record.push_back(
N->isLocalToUnit());
1637 Record.push_back(
N->isDefinition());
1648 Record.push_back(
N->isDistinct());
1649 Record.push_back(
N->getTag());
1653 Record.push_back(
N->getLine());
1655 Record.push_back(
N->getArg());
1656 Record.push_back(
N->getFlags());
1662void DXILBitcodeWriter::writeDIExpression(
const DIExpression *
N,
1665 Record.reserve(
N->getElements().size() + 1);
1667 Record.push_back(
N->isDistinct());
1668 Record.append(
N->elements_begin(),
N->elements_end());
1683 Record.push_back(
N->isDistinct());
1684 Record.push_back(
N->getTag());
1687 Record.push_back(
N->getLine());
1694unsigned DXILBitcodeWriter::createDILocationAbbrev() {
1699 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1709unsigned DXILBitcodeWriter::createGenericDINodeAbbrev() {
1714 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1727 std::vector<unsigned> *MDAbbrevs,
1728 std::vector<uint64_t> *IndexPos) {
1733#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
1734#include "llvm/IR/Metadata.def"
1739 if (
const MDNode *
N = dyn_cast<MDNode>(MD)) {
1740 assert(
N->isResolved() &&
"Expected forward references to be resolved");
1742 switch (
N->getMetadataID()) {
1745#define HANDLE_MDNODE_LEAF(CLASS) \
1746 case Metadata::CLASS##Kind: \
1748 write##CLASS(cast<CLASS>(N), Record, \
1749 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
1751 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
1753#include "llvm/IR/Metadata.def"
1756 writeValueAsMetadata(cast<ValueAsMetadata>(MD),
Record);
1760unsigned DXILBitcodeWriter::createMetadataStringsAbbrev() {
1761 auto Abbv = std::make_shared<BitCodeAbbrev>();
1768void DXILBitcodeWriter::writeMetadataStrings(
1770 if (Strings.empty())
1773 unsigned MDSAbbrev = createMetadataStringsAbbrev();
1775 for (
const Metadata *MD : Strings) {
1776 const MDString *MDS = cast<MDString>(MD);
1786void DXILBitcodeWriter::writeModuleMetadata() {
1787 if (!VE.
hasMDs() &&
M.named_metadata_empty())
1794 std::vector<unsigned> MDAbbrevs;
1797 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
1798 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
1799 createGenericDINodeAbbrev();
1801 unsigned NameAbbrev = 0;
1802 if (!
M.named_metadata_empty()) {
1804 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1808 NameAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1814 std::vector<uint64_t> IndexPos;
1822 Record.append(Str.bytes_begin(), Str.bytes_end());
1827 for (
const MDNode *
N : NMD.operands())
1836void DXILBitcodeWriter::writeFunctionMetadata(
const Function &
F) {
1847void DXILBitcodeWriter::writeFunctionMetadataAttachment(
const Function &
F) {
1855 F.getAllMetadata(MDs);
1857 for (
const auto &
I : MDs) {
1868 I.getAllMetadataOtherThanDebugLoc(MDs);
1876 for (
unsigned i = 0, e = MDs.size(); i != e; ++i) {
1877 Record.push_back(MDs[i].first);
1887void DXILBitcodeWriter::writeModuleMetadataKinds() {
1893 M.getMDKindNames(Names);
1900 for (
unsigned MDKindID = 0, e = Names.
size(); MDKindID != e; ++MDKindID) {
1901 Record.push_back(MDKindID);
1912void DXILBitcodeWriter::writeConstants(
unsigned FirstVal,
unsigned LastVal,
1914 if (FirstVal == LastVal)
1919 unsigned AggregateAbbrev = 0;
1920 unsigned String8Abbrev = 0;
1921 unsigned CString7Abbrev = 0;
1922 unsigned CString6Abbrev = 0;
1926 auto Abbv = std::make_shared<BitCodeAbbrev>();
1931 AggregateAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1934 Abbv = std::make_shared<BitCodeAbbrev>();
1938 String8Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1940 Abbv = std::make_shared<BitCodeAbbrev>();
1944 CString7Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1946 Abbv = std::make_shared<BitCodeAbbrev>();
1950 CString6Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1956 Type *LastTy =
nullptr;
1957 for (
unsigned i = FirstVal; i != LastVal; ++i) {
1958 const Value *
V = Vals[i].first;
1960 if (
V->getType() != LastTy) {
1961 LastTy =
V->getType();
1962 Record.push_back(getTypeID(LastTy, V));
1964 CONSTANTS_SETTYPE_ABBREV);
1968 if (
const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
1969 Record.push_back(
unsigned(
IA->hasSideEffects()) |
1970 unsigned(
IA->isAlignStack()) << 1 |
1971 unsigned(
IA->getDialect() & 1) << 2);
1974 const std::string &AsmStr =
IA->getAsmString();
1975 Record.push_back(AsmStr.size());
1976 Record.append(AsmStr.begin(), AsmStr.end());
1979 const std::string &ConstraintStr =
IA->getConstraintString();
1980 Record.push_back(ConstraintStr.size());
1981 Record.append(ConstraintStr.begin(), ConstraintStr.end());
1987 unsigned Code = -1U;
1988 unsigned AbbrevToUse = 0;
1989 if (
C->isNullValue()) {
1991 }
else if (isa<UndefValue>(
C)) {
1994 if (
IV->getBitWidth() <= 64) {
1998 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2004 unsigned NWords =
IV->getValue().getActiveWords();
2005 const uint64_t *RawWords =
IV->getValue().getRawData();
2006 for (
unsigned i = 0; i != NWords; ++i) {
2011 }
else if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(
C)) {
2013 Type *Ty = CFP->getType();
2015 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2019 APInt api = CFP->getValueAPF().bitcastToAPInt();
2021 Record.push_back((p[1] << 48) | (p[0] >> 16));
2022 Record.push_back(p[0] & 0xffffLL);
2024 APInt api = CFP->getValueAPF().bitcastToAPInt();
2029 assert(0 &&
"Unknown FP type!");
2031 }
else if (isa<ConstantDataSequential>(
C) &&
2032 cast<ConstantDataSequential>(
C)->isString()) {
2035 unsigned NumElts = Str->getNumElements();
2037 if (Str->isCString()) {
2042 AbbrevToUse = String8Abbrev;
2046 for (
unsigned i = 0; i != NumElts; ++i) {
2047 unsigned char V = Str->getElementAsInteger(i);
2049 isCStr7 &= (
V & 128) == 0;
2055 AbbrevToUse = CString6Abbrev;
2057 AbbrevToUse = CString7Abbrev;
2059 dyn_cast<ConstantDataSequential>(
C)) {
2061 Type *EltTy = CDS->getElementType();
2062 if (isa<IntegerType>(EltTy)) {
2063 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
2064 Record.push_back(CDS->getElementAsInteger(i));
2066 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
2071 F = CDS->getElementAsFloat(i);
2076 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
2081 F = CDS->getElementAsDouble(i);
2085 }
else if (isa<ConstantArray>(
C) || isa<ConstantStruct>(
C) ||
2086 isa<ConstantVector>(
C)) {
2088 for (
const Value *
Op :
C->operands())
2090 AbbrevToUse = AggregateAbbrev;
2091 }
else if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(
C)) {
2092 switch (
CE->getOpcode()) {
2098 getTypeID(
C->getOperand(0)->getType(),
C->getOperand(0)));
2100 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2102 assert(
CE->getNumOperands() == 2 &&
"Unknown constant expr!");
2112 case Instruction::GetElementPtr: {
2114 const auto *GO = cast<GEPOperator>(
C);
2115 if (GO->isInBounds())
2117 Record.push_back(getTypeID(GO->getSourceElementType()));
2118 for (
unsigned i = 0, e =
CE->getNumOperands(); i != e; ++i) {
2120 getTypeID(
C->getOperand(i)->getType(),
C->getOperand(i)));
2125 case Instruction::Select:
2131 case Instruction::ExtractElement:
2133 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2135 Record.push_back(getTypeID(
C->getOperand(1)->getType()));
2138 case Instruction::InsertElement:
2142 Record.push_back(getTypeID(
C->getOperand(2)->getType()));
2145 case Instruction::ShuffleVector:
2150 if (
C->getType() ==
C->getOperand(0)->getType()) {
2154 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2161 }
else if (
const BlockAddress *BA = dyn_cast<BlockAddress>(
C)) {
2163 Record.push_back(getTypeID(BA->getFunction()->getType()));
2179void DXILBitcodeWriter::writeModuleConstants() {
2184 for (
unsigned i = 0, e = Vals.size(); i != e; ++i) {
2185 if (!isa<GlobalValue>(Vals[i].first)) {
2186 writeConstants(i, Vals.size(),
true);
2200bool DXILBitcodeWriter::pushValueAndType(
const Value *V,
unsigned InstID,
2205 if (
ValID >= InstID) {
2214void DXILBitcodeWriter::pushValue(
const Value *V,
unsigned InstID,
2220void DXILBitcodeWriter::pushValueSigned(
const Value *V,
unsigned InstID,
2223 int64_t diff = ((int32_t)InstID - (int32_t)
ValID);
2228void DXILBitcodeWriter::writeInstruction(
const Instruction &
I,
unsigned InstID,
2231 unsigned AbbrevToUse = 0;
2233 switch (
I.getOpcode()) {
2237 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2238 AbbrevToUse = (
unsigned)FUNCTION_INST_CAST_ABBREV;
2242 assert(isa<BinaryOperator>(
I) &&
"Unknown instruction!");
2244 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2245 AbbrevToUse = (
unsigned)FUNCTION_INST_BINOP_ABBREV;
2246 pushValue(
I.getOperand(1), InstID, Vals);
2250 if (AbbrevToUse == (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2251 AbbrevToUse = (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV;
2257 case Instruction::GetElementPtr: {
2259 AbbrevToUse = (
unsigned)FUNCTION_INST_GEP_ABBREV;
2260 auto &GEPInst = cast<GetElementPtrInst>(
I);
2262 Vals.
push_back(getTypeID(GEPInst.getSourceElementType()));
2263 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i)
2264 pushValueAndType(
I.getOperand(i), InstID, Vals);
2267 case Instruction::ExtractValue: {
2269 pushValueAndType(
I.getOperand(0), InstID, Vals);
2274 case Instruction::InsertValue: {
2276 pushValueAndType(
I.getOperand(0), InstID, Vals);
2277 pushValueAndType(
I.getOperand(1), InstID, Vals);
2282 case Instruction::Select:
2284 pushValueAndType(
I.getOperand(1), InstID, Vals);
2285 pushValue(
I.getOperand(2), InstID, Vals);
2286 pushValueAndType(
I.getOperand(0), InstID, Vals);
2288 case Instruction::ExtractElement:
2290 pushValueAndType(
I.getOperand(0), InstID, Vals);
2291 pushValueAndType(
I.getOperand(1), InstID, Vals);
2293 case Instruction::InsertElement:
2295 pushValueAndType(
I.getOperand(0), InstID, Vals);
2296 pushValue(
I.getOperand(1), InstID, Vals);
2297 pushValueAndType(
I.getOperand(2), InstID, Vals);
2299 case Instruction::ShuffleVector:
2301 pushValueAndType(
I.getOperand(0), InstID, Vals);
2302 pushValue(
I.getOperand(1), InstID, Vals);
2303 pushValue(cast<ShuffleVectorInst>(&
I)->getShuffleMaskForBitcode(), InstID,
2306 case Instruction::ICmp:
2307 case Instruction::FCmp: {
2310 pushValueAndType(
I.getOperand(0), InstID, Vals);
2311 pushValue(
I.getOperand(1), InstID, Vals);
2319 case Instruction::Ret: {
2321 unsigned NumOperands =
I.getNumOperands();
2322 if (NumOperands == 0)
2323 AbbrevToUse = (
unsigned)FUNCTION_INST_RET_VOID_ABBREV;
2324 else if (NumOperands == 1) {
2325 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2326 AbbrevToUse = (
unsigned)FUNCTION_INST_RET_VAL_ABBREV;
2328 for (
unsigned i = 0, e = NumOperands; i !=
e; ++i)
2329 pushValueAndType(
I.getOperand(i), InstID, Vals);
2332 case Instruction::Br: {
2336 if (
II.isConditional()) {
2338 pushValue(
II.getCondition(), InstID, Vals);
2341 case Instruction::Switch: {
2344 Vals.
push_back(getTypeID(
SI.getCondition()->getType()));
2345 pushValue(
SI.getCondition(), InstID, Vals);
2347 for (
auto Case :
SI.cases()) {
2352 case Instruction::IndirectBr:
2354 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2356 pushValue(
I.getOperand(0), InstID, Vals);
2357 for (
unsigned i = 1, e =
I.getNumOperands(); i != e; ++i)
2361 case Instruction::Invoke: {
2372 pushValueAndType(Callee, InstID, Vals);
2375 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2376 pushValue(
I.getOperand(i), InstID, Vals);
2379 if (FTy->isVarArg()) {
2380 for (
unsigned i = FTy->getNumParams(), e =
I.getNumOperands() - 3; i != e;
2382 pushValueAndType(
I.getOperand(i), InstID, Vals);
2386 case Instruction::Resume:
2388 pushValueAndType(
I.getOperand(0), InstID, Vals);
2390 case Instruction::Unreachable:
2392 AbbrevToUse = (
unsigned)FUNCTION_INST_UNREACHABLE_ABBREV;
2395 case Instruction::PHI: {
2396 const PHINode &PN = cast<PHINode>(
I);
2408 Stream.
EmitRecord(Code, Vals64, AbbrevToUse);
2413 case Instruction::LandingPad: {
2424 pushValueAndType(LP.
getClause(
I), InstID, Vals);
2429 case Instruction::Alloca: {
2433 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2436 assert(AlignRecord < 1 << 5 &&
"alignment greater than 1 << 64");
2438 AlignRecord |= 1 << 6;
2443 case Instruction::Load:
2444 if (cast<LoadInst>(
I).isAtomic()) {
2446 pushValueAndType(
I.getOperand(0), InstID, Vals);
2449 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2450 AbbrevToUse = (
unsigned)FUNCTION_INST_LOAD_ABBREV;
2454 Vals.
push_back(cast<LoadInst>(
I).isVolatile());
2455 if (cast<LoadInst>(
I).isAtomic()) {
2457 Vals.
push_back(getEncodedSyncScopeID(cast<LoadInst>(
I).getSyncScopeID()));
2460 case Instruction::Store:
2461 if (cast<StoreInst>(
I).isAtomic())
2465 pushValueAndType(
I.getOperand(1), InstID, Vals);
2466 pushValueAndType(
I.getOperand(0), InstID, Vals);
2468 Vals.
push_back(cast<StoreInst>(
I).isVolatile());
2469 if (cast<StoreInst>(
I).isAtomic()) {
2472 getEncodedSyncScopeID(cast<StoreInst>(
I).getSyncScopeID()));
2475 case Instruction::AtomicCmpXchg:
2477 pushValueAndType(
I.getOperand(0), InstID, Vals);
2478 pushValueAndType(
I.getOperand(1), InstID, Vals);
2479 pushValue(
I.getOperand(2), InstID, Vals);
2480 Vals.
push_back(cast<AtomicCmpXchgInst>(
I).isVolatile());
2484 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(
I).getSyncScopeID()));
2487 Vals.
push_back(cast<AtomicCmpXchgInst>(
I).isWeak());
2489 case Instruction::AtomicRMW:
2491 pushValueAndType(
I.getOperand(0), InstID, Vals);
2492 pushValue(
I.getOperand(1), InstID, Vals);
2495 Vals.
push_back(cast<AtomicRMWInst>(
I).isVolatile());
2498 getEncodedSyncScopeID(cast<AtomicRMWInst>(
I).getSyncScopeID()));
2500 case Instruction::Fence:
2503 Vals.
push_back(getEncodedSyncScopeID(cast<FenceInst>(
I).getSyncScopeID()));
2505 case Instruction::Call: {
2518 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
2520 if (FTy->getParamType(i)->isLabelTy())
2527 if (FTy->isVarArg()) {
2528 for (
unsigned i = FTy->getNumParams(), e = CI.
arg_size(); i != e; ++i)
2533 case Instruction::VAArg:
2535 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2536 pushValue(
I.getOperand(0), InstID, Vals);
2546void DXILBitcodeWriter::writeFunctionLevelValueSymbolTable(
2559 for (
auto &VI : VST) {
2564 return A->first() <
B->first();
2567 for (
const ValueName *SI : SortedTable) {
2572 bool isChar6 =
true;
2573 for (
const char *
C =
Name.getKeyData(), *E =
C +
Name.getKeyLength();
2577 if ((
unsigned char)*
C & 128) {
2583 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
2588 if (isa<BasicBlock>(
SI->getValue())) {
2591 AbbrevToUse = VST_BBENTRY_6_ABBREV;
2595 AbbrevToUse = VST_ENTRY_6_ABBREV;
2597 AbbrevToUse = VST_ENTRY_7_ABBREV;
2601 for (
const char *
P =
Name.getKeyData(),
2602 *E =
Name.getKeyData() +
Name.getKeyLength();
2607 Stream.
EmitRecord(Code, NameVals, AbbrevToUse);
2614void DXILBitcodeWriter::writeFunction(
const Function &
F) {
2627 unsigned CstStart, CstEnd;
2629 writeConstants(CstStart, CstEnd,
false);
2632 writeFunctionMetadata(
F);
2635 unsigned InstID = CstEnd;
2637 bool NeedsMetadataAttachment =
F.hasMetadata();
2645 writeInstruction(*
I, InstID, Vals);
2647 if (!
I->getType()->isVoidTy())
2651 NeedsMetadataAttachment |=
I->hasMetadataOtherThanDebugLoc();
2675 if (
auto *Symtab =
F.getValueSymbolTable())
2676 writeFunctionLevelValueSymbolTable(*Symtab);
2678 if (NeedsMetadataAttachment)
2679 writeFunctionMetadataAttachment(
F);
2686void DXILBitcodeWriter::writeBlockInfo() {
2693 auto Abbv = std::make_shared<BitCodeAbbrev>();
2699 std::move(Abbv)) != VST_ENTRY_8_ABBREV)
2700 assert(
false &&
"Unexpected abbrev ordering!");
2704 auto Abbv = std::make_shared<BitCodeAbbrev>();
2710 std::move(Abbv)) != VST_ENTRY_7_ABBREV)
2711 assert(
false &&
"Unexpected abbrev ordering!");
2714 auto Abbv = std::make_shared<BitCodeAbbrev>();
2720 std::move(Abbv)) != VST_ENTRY_6_ABBREV)
2721 assert(
false &&
"Unexpected abbrev ordering!");
2724 auto Abbv = std::make_shared<BitCodeAbbrev>();
2730 std::move(Abbv)) != VST_BBENTRY_6_ABBREV)
2731 assert(
false &&
"Unexpected abbrev ordering!");
2735 auto Abbv = std::make_shared<BitCodeAbbrev>();
2740 CONSTANTS_SETTYPE_ABBREV)
2741 assert(
false &&
"Unexpected abbrev ordering!");
2745 auto Abbv = std::make_shared<BitCodeAbbrev>();
2749 CONSTANTS_INTEGER_ABBREV)
2750 assert(
false &&
"Unexpected abbrev ordering!");
2754 auto Abbv = std::make_shared<BitCodeAbbrev>();
2762 CONSTANTS_CE_CAST_Abbrev)
2763 assert(
false &&
"Unexpected abbrev ordering!");
2766 auto Abbv = std::make_shared<BitCodeAbbrev>();
2769 CONSTANTS_NULL_Abbrev)
2770 assert(
false &&
"Unexpected abbrev ordering!");
2776 auto Abbv = std::make_shared<BitCodeAbbrev>();
2784 (
unsigned)FUNCTION_INST_LOAD_ABBREV)
2785 assert(
false &&
"Unexpected abbrev ordering!");
2788 auto Abbv = std::make_shared<BitCodeAbbrev>();
2794 (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2795 assert(
false &&
"Unexpected abbrev ordering!");
2798 auto Abbv = std::make_shared<BitCodeAbbrev>();
2805 (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV)
2806 assert(
false &&
"Unexpected abbrev ordering!");
2809 auto Abbv = std::make_shared<BitCodeAbbrev>();
2816 (
unsigned)FUNCTION_INST_CAST_ABBREV)
2817 assert(
false &&
"Unexpected abbrev ordering!");
2821 auto Abbv = std::make_shared<BitCodeAbbrev>();
2824 (
unsigned)FUNCTION_INST_RET_VOID_ABBREV)
2825 assert(
false &&
"Unexpected abbrev ordering!");
2828 auto Abbv = std::make_shared<BitCodeAbbrev>();
2832 (
unsigned)FUNCTION_INST_RET_VAL_ABBREV)
2833 assert(
false &&
"Unexpected abbrev ordering!");
2836 auto Abbv = std::make_shared<BitCodeAbbrev>();
2839 (
unsigned)FUNCTION_INST_UNREACHABLE_ABBREV)
2840 assert(
false &&
"Unexpected abbrev ordering!");
2843 auto Abbv = std::make_shared<BitCodeAbbrev>();
2851 (
unsigned)FUNCTION_INST_GEP_ABBREV)
2852 assert(
false &&
"Unexpected abbrev ordering!");
2858void DXILBitcodeWriter::writeModuleVersion() {
2873 DXILBitcodeWriter::writeModuleVersion();
2879 writeAttributeGroupTable();
2882 writeAttributeTable();
2894 writeModuleConstants();
2897 writeModuleMetadataKinds();
2900 writeModuleMetadata();
2905 writeFunctionLevelValueSymbolTable(M.getValueSymbolTable());
2909 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.
uint64_t IntrinsicInst * II
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.
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
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_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.
void writeModule(const Module &M)
Write the specified module to the buffer specified at construction time.
BitcodeWriter(SmallVectorImpl< char > &Buffer)
Create a BitcodeWriter that writes to Buffer.
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
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.