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()) {
1067 AbbrevToUse = PtrAbbrev;
1078 "dxilOpaquePtrReservedName", StructNameAbbrev);
1086 TypeVals.
push_back(getTypeID(FT->getReturnType()));
1087 for (
Type *PTy : FT->params())
1089 AbbrevToUse = FunctionAbbrev;
1097 for (
Type *ElTy :
ST->elements())
1100 if (
ST->isLiteral()) {
1102 AbbrevToUse = StructAnonAbbrev;
1104 if (
ST->isOpaque()) {
1108 AbbrevToUse = StructNamedAbbrev;
1112 if (!
ST->getName().empty())
1122 TypeVals.
push_back(AT->getNumElements());
1123 TypeVals.
push_back(getTypeID(AT->getElementType()));
1124 AbbrevToUse = ArrayAbbrev;
1132 TypeVals.
push_back(VT->getElementCount().getKnownMinValue());
1133 TypeVals.
push_back(getTypeID(VT->getElementType()));
1139 Stream.
EmitRecord(Code, TypeVals, AbbrevToUse);
1146void DXILBitcodeWriter::writeComdats() {
1151 size_t Size =
C->getName().size();
1154 for (
char Chr :
C->getName())
1161void DXILBitcodeWriter::writeValueSymbolTableForwardDecl() {}
1166void DXILBitcodeWriter::writeModuleInfo() {
1168 if (!
M.getTargetTriple().empty())
1171 const std::string &
DL =
M.getDataLayoutStr();
1174 if (!
M.getModuleInlineAsm().empty())
1180 std::map<std::string, unsigned> SectionMap;
1181 std::map<std::string, unsigned> GCMap;
1183 unsigned MaxGlobalType = 0;
1184 const auto UpdateMaxAlignment = [&MaxAlignment](
const MaybeAlign A) {
1186 MaxAlignment = !MaxAlignment ? *
A : std::max(*MaxAlignment, *
A);
1189 UpdateMaxAlignment(GV.getAlign());
1192 MaxGlobalType = std::max(
1193 MaxGlobalType, getGlobalObjectValueTypeID(GV.getValueType(), &GV));
1194 if (GV.hasSection()) {
1196 unsigned &
Entry = SectionMap[std::string(GV.getSection())];
1199 GV.getSection(), 0 );
1200 Entry = SectionMap.size();
1205 UpdateMaxAlignment(
F.getAlign());
1206 if (
F.hasSection()) {
1208 unsigned &
Entry = SectionMap[std::string(
F.getSection())];
1212 Entry = SectionMap.size();
1217 unsigned &
Entry = GCMap[
F.getGC()];
1221 Entry = GCMap.size();
1227 unsigned SimpleGVarAbbrev = 0;
1228 if (!
M.global_empty()) {
1231 auto Abbv = std::make_shared<BitCodeAbbrev>();
1243 unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment);
1247 if (SectionMap.empty())
1253 SimpleGVarAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1259 unsigned AbbrevToUse = 0;
1265 Vals.
push_back(getGlobalObjectValueTypeID(GV.getValueType(), &GV));
1267 GV.getType()->getAddressSpace() << 2 | 2 |
1268 (GV.isConstant() ? 1 : 0));
1271 GV.isDeclaration() ? 0 : (VE.
getValueID(GV.getInitializer()) + 1));
1273 Vals.
push_back(getEncodedAlign(GV.getAlign()));
1274 Vals.
push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
1276 if (GV.isThreadLocal() ||
1279 GV.isExternallyInitialized() ||
1285 Vals.
push_back(GV.isExternallyInitialized());
1289 AbbrevToUse = SimpleGVarAbbrev;
1301 Vals.
push_back(getGlobalObjectValueTypeID(
F.getFunctionType(), &
F));
1306 Vals.
push_back(getEncodedAlign(
F.getAlign()));
1307 Vals.
push_back(
F.hasSection() ? SectionMap[std::string(
F.getSection())]
1313 F.hasPrologueData() ? (VE.
getValueID(
F.getPrologueData()) + 1) : 0);
1319 F.hasPersonalityFn() ? (VE.
getValueID(
F.getPersonalityFn()) + 1) : 0);
1321 unsigned AbbrevToUse = 0;
1336 unsigned AbbrevToUse = 0;
1342void DXILBitcodeWriter::writeValueAsMetadata(
1346 Type *Ty =
V->getType();
1347 if (
Function *
F = dyn_cast<Function>(V))
1351 Record.push_back(getTypeID(Ty));
1357void DXILBitcodeWriter::writeMDTuple(
const MDTuple *
N,
1360 for (
unsigned i = 0, e =
N->getNumOperands(); i != e; ++i) {
1362 assert(!(MD && isa<LocalAsMetadata>(MD)) &&
1363 "Unexpected function-local metadata");
1372void DXILBitcodeWriter::writeDILocation(
const DILocation *
N,
1376 Abbrev = createDILocationAbbrev();
1377 Record.push_back(
N->isDistinct());
1378 Record.push_back(
N->getLine());
1379 Record.push_back(
N->getColumn());
1390 return I < 0 ? ~(U << 1) : U << 1;
1393void DXILBitcodeWriter::writeDISubrange(
const DISubrange *
N,
1396 Record.push_back(
N->isDistinct());
1401 assert(Count &&
"Count is missing or not ConstantInt");
1405 DISubrange::BoundType LowerBound =
N->getLowerBound();
1407 "Lower bound provided but not ConstantInt");
1415void DXILBitcodeWriter::writeDIEnumerator(
const DIEnumerator *
N,
1418 Record.push_back(
N->isDistinct());
1426void DXILBitcodeWriter::writeDIBasicType(
const DIBasicType *
N,
1429 Record.push_back(
N->isDistinct());
1430 Record.push_back(
N->getTag());
1432 Record.push_back(
N->getSizeInBits());
1433 Record.push_back(
N->getAlignInBits());
1434 Record.push_back(
N->getEncoding());
1440void DXILBitcodeWriter::writeDIDerivedType(
const DIDerivedType *
N,
1443 Record.push_back(
N->isDistinct());
1444 Record.push_back(
N->getTag());
1447 Record.push_back(
N->getLine());
1450 Record.push_back(
N->getSizeInBits());
1451 Record.push_back(
N->getAlignInBits());
1452 Record.push_back(
N->getOffsetInBits());
1453 Record.push_back(
N->getFlags());
1463 Record.push_back(
N->isDistinct());
1464 Record.push_back(
N->getTag());
1467 Record.push_back(
N->getLine());
1470 Record.push_back(
N->getSizeInBits());
1471 Record.push_back(
N->getAlignInBits());
1472 Record.push_back(
N->getOffsetInBits());
1473 Record.push_back(
N->getFlags());
1475 Record.push_back(
N->getRuntimeLang());
1487 Record.push_back(
N->isDistinct());
1488 Record.push_back(
N->getFlags());
1495void DXILBitcodeWriter::writeDIFile(
const DIFile *
N,
1498 Record.push_back(
N->isDistinct());
1506void DXILBitcodeWriter::writeDICompileUnit(
const DICompileUnit *
N,
1509 Record.push_back(
N->isDistinct());
1510 Record.push_back(
N->getSourceLanguage());
1513 Record.push_back(
N->isOptimized());
1515 Record.push_back(
N->getRuntimeVersion());
1517 Record.push_back(
N->getEmissionKind());
1523 Record.push_back(
N->getDWOId());
1529void DXILBitcodeWriter::writeDISubprogram(
const DISubprogram *
N,
1532 Record.push_back(
N->isDistinct());
1537 Record.push_back(
N->getLine());
1539 Record.push_back(
N->isLocalToUnit());
1540 Record.push_back(
N->isDefinition());
1541 Record.push_back(
N->getScopeLine());
1543 Record.push_back(
N->getVirtuality());
1544 Record.push_back(
N->getVirtualIndex());
1545 Record.push_back(
N->getFlags());
1546 Record.push_back(
N->isOptimized());
1559 Record.push_back(
N->isDistinct());
1562 Record.push_back(
N->getLine());
1563 Record.push_back(
N->getColumn());
1569void DXILBitcodeWriter::writeDILexicalBlockFile(
1572 Record.push_back(
N->isDistinct());
1575 Record.push_back(
N->getDiscriminator());
1581void DXILBitcodeWriter::writeDINamespace(
const DINamespace *
N,
1584 Record.push_back(
N->isDistinct());
1594void DXILBitcodeWriter::writeDIModule(
const DIModule *
N,
1597 Record.push_back(
N->isDistinct());
1598 for (
auto &
I :
N->operands())
1605void DXILBitcodeWriter::writeDITemplateTypeParameter(
1608 Record.push_back(
N->isDistinct());
1616void DXILBitcodeWriter::writeDITemplateValueParameter(
1619 Record.push_back(
N->isDistinct());
1620 Record.push_back(
N->getTag());
1632 Record.push_back(
N->isDistinct());
1637 Record.push_back(
N->getLine());
1639 Record.push_back(
N->isLocalToUnit());
1640 Record.push_back(
N->isDefinition());
1651 Record.push_back(
N->isDistinct());
1652 Record.push_back(
N->getTag());
1656 Record.push_back(
N->getLine());
1658 Record.push_back(
N->getArg());
1659 Record.push_back(
N->getFlags());
1665void DXILBitcodeWriter::writeDIExpression(
const DIExpression *
N,
1668 Record.reserve(
N->getElements().size() + 1);
1670 Record.push_back(
N->isDistinct());
1671 Record.append(
N->elements_begin(),
N->elements_end());
1686 Record.push_back(
N->isDistinct());
1687 Record.push_back(
N->getTag());
1690 Record.push_back(
N->getLine());
1697unsigned DXILBitcodeWriter::createDILocationAbbrev() {
1702 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1712unsigned DXILBitcodeWriter::createGenericDINodeAbbrev() {
1717 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1730 std::vector<unsigned> *MDAbbrevs,
1731 std::vector<uint64_t> *IndexPos) {
1736#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0;
1737#include "llvm/IR/Metadata.def"
1742 if (
const MDNode *
N = dyn_cast<MDNode>(MD)) {
1743 assert(
N->isResolved() &&
"Expected forward references to be resolved");
1745 switch (
N->getMetadataID()) {
1748#define HANDLE_MDNODE_LEAF(CLASS) \
1749 case Metadata::CLASS##Kind: \
1751 write##CLASS(cast<CLASS>(N), Record, \
1752 (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \
1754 write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \
1756#include "llvm/IR/Metadata.def"
1759 writeValueAsMetadata(cast<ValueAsMetadata>(MD),
Record);
1763unsigned DXILBitcodeWriter::createMetadataStringsAbbrev() {
1764 auto Abbv = std::make_shared<BitCodeAbbrev>();
1771void DXILBitcodeWriter::writeMetadataStrings(
1773 if (Strings.empty())
1776 unsigned MDSAbbrev = createMetadataStringsAbbrev();
1778 for (
const Metadata *MD : Strings) {
1779 const MDString *MDS = cast<MDString>(MD);
1789void DXILBitcodeWriter::writeModuleMetadata() {
1790 if (!VE.
hasMDs() &&
M.named_metadata_empty())
1797 std::vector<unsigned> MDAbbrevs;
1800 MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev();
1801 MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] =
1802 createGenericDINodeAbbrev();
1804 unsigned NameAbbrev = 0;
1805 if (!
M.named_metadata_empty()) {
1807 std::shared_ptr<BitCodeAbbrev> Abbv = std::make_shared<BitCodeAbbrev>();
1811 NameAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1817 std::vector<uint64_t> IndexPos;
1825 Record.append(Str.bytes_begin(), Str.bytes_end());
1830 for (
const MDNode *
N : NMD.operands())
1839void DXILBitcodeWriter::writeFunctionMetadata(
const Function &
F) {
1850void DXILBitcodeWriter::writeFunctionMetadataAttachment(
const Function &
F) {
1858 F.getAllMetadata(MDs);
1860 for (
const auto &
I : MDs) {
1871 I.getAllMetadataOtherThanDebugLoc(MDs);
1879 for (
unsigned i = 0, e = MDs.size(); i != e; ++i) {
1880 Record.push_back(MDs[i].first);
1890void DXILBitcodeWriter::writeModuleMetadataKinds() {
1896 M.getMDKindNames(Names);
1903 for (
unsigned MDKindID = 0, e = Names.
size(); MDKindID != e; ++MDKindID) {
1904 Record.push_back(MDKindID);
1915void DXILBitcodeWriter::writeConstants(
unsigned FirstVal,
unsigned LastVal,
1917 if (FirstVal == LastVal)
1922 unsigned AggregateAbbrev = 0;
1923 unsigned String8Abbrev = 0;
1924 unsigned CString7Abbrev = 0;
1925 unsigned CString6Abbrev = 0;
1929 auto Abbv = std::make_shared<BitCodeAbbrev>();
1934 AggregateAbbrev = Stream.
EmitAbbrev(std::move(Abbv));
1937 Abbv = std::make_shared<BitCodeAbbrev>();
1941 String8Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1943 Abbv = std::make_shared<BitCodeAbbrev>();
1947 CString7Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1949 Abbv = std::make_shared<BitCodeAbbrev>();
1953 CString6Abbrev = Stream.
EmitAbbrev(std::move(Abbv));
1959 Type *LastTy =
nullptr;
1960 for (
unsigned i = FirstVal; i != LastVal; ++i) {
1961 const Value *
V = Vals[i].first;
1963 if (
V->getType() != LastTy) {
1964 LastTy =
V->getType();
1965 Record.push_back(getTypeID(LastTy, V));
1967 CONSTANTS_SETTYPE_ABBREV);
1971 if (
const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
1972 Record.push_back(
unsigned(
IA->hasSideEffects()) |
1973 unsigned(
IA->isAlignStack()) << 1 |
1974 unsigned(
IA->getDialect() & 1) << 2);
1977 const std::string &AsmStr =
IA->getAsmString();
1978 Record.push_back(AsmStr.size());
1979 Record.append(AsmStr.begin(), AsmStr.end());
1982 const std::string &ConstraintStr =
IA->getConstraintString();
1983 Record.push_back(ConstraintStr.size());
1984 Record.append(ConstraintStr.begin(), ConstraintStr.end());
1990 unsigned Code = -1U;
1991 unsigned AbbrevToUse = 0;
1992 if (
C->isNullValue()) {
1994 }
else if (isa<UndefValue>(
C)) {
1997 if (
IV->getBitWidth() <= 64) {
2001 AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
2007 unsigned NWords =
IV->getValue().getActiveWords();
2008 const uint64_t *RawWords =
IV->getValue().getRawData();
2009 for (
unsigned i = 0; i != NWords; ++i) {
2014 }
else if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(
C)) {
2016 Type *Ty = CFP->getType();
2018 Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
2022 APInt api = CFP->getValueAPF().bitcastToAPInt();
2024 Record.push_back((p[1] << 48) | (p[0] >> 16));
2025 Record.push_back(p[0] & 0xffffLL);
2027 APInt api = CFP->getValueAPF().bitcastToAPInt();
2032 assert(0 &&
"Unknown FP type!");
2034 }
else if (isa<ConstantDataSequential>(
C) &&
2035 cast<ConstantDataSequential>(
C)->isString()) {
2038 unsigned NumElts = Str->getNumElements();
2040 if (Str->isCString()) {
2045 AbbrevToUse = String8Abbrev;
2049 for (
unsigned i = 0; i != NumElts; ++i) {
2050 unsigned char V = Str->getElementAsInteger(i);
2052 isCStr7 &= (
V & 128) == 0;
2058 AbbrevToUse = CString6Abbrev;
2060 AbbrevToUse = CString7Abbrev;
2062 dyn_cast<ConstantDataSequential>(
C)) {
2064 Type *EltTy = CDS->getElementType();
2065 if (isa<IntegerType>(EltTy)) {
2066 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
2067 Record.push_back(CDS->getElementAsInteger(i));
2069 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
2074 F = CDS->getElementAsFloat(i);
2079 for (
unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
2084 F = CDS->getElementAsDouble(i);
2088 }
else if (isa<ConstantArray>(
C) || isa<ConstantStruct>(
C) ||
2089 isa<ConstantVector>(
C)) {
2091 for (
const Value *
Op :
C->operands())
2093 AbbrevToUse = AggregateAbbrev;
2094 }
else if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(
C)) {
2095 switch (
CE->getOpcode()) {
2101 getTypeID(
C->getOperand(0)->getType(),
C->getOperand(0)));
2103 AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
2105 assert(
CE->getNumOperands() == 2 &&
"Unknown constant expr!");
2115 case Instruction::GetElementPtr: {
2117 const auto *GO = cast<GEPOperator>(
C);
2118 if (GO->isInBounds())
2120 Record.push_back(getTypeID(GO->getSourceElementType()));
2121 for (
unsigned i = 0, e =
CE->getNumOperands(); i != e; ++i) {
2123 getTypeID(
C->getOperand(i)->getType(),
C->getOperand(i)));
2128 case Instruction::Select:
2134 case Instruction::ExtractElement:
2136 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2138 Record.push_back(getTypeID(
C->getOperand(1)->getType()));
2141 case Instruction::InsertElement:
2145 Record.push_back(getTypeID(
C->getOperand(2)->getType()));
2148 case Instruction::ShuffleVector:
2153 if (
C->getType() ==
C->getOperand(0)->getType()) {
2157 Record.push_back(getTypeID(
C->getOperand(0)->getType()));
2164 }
else if (
const BlockAddress *BA = dyn_cast<BlockAddress>(
C)) {
2166 Record.push_back(getTypeID(BA->getFunction()->getType()));
2182void DXILBitcodeWriter::writeModuleConstants() {
2187 for (
unsigned i = 0, e = Vals.size(); i != e; ++i) {
2188 if (!isa<GlobalValue>(Vals[i].first)) {
2189 writeConstants(i, Vals.size(),
true);
2203bool DXILBitcodeWriter::pushValueAndType(
const Value *V,
unsigned InstID,
2208 if (
ValID >= InstID) {
2217void DXILBitcodeWriter::pushValue(
const Value *V,
unsigned InstID,
2223void DXILBitcodeWriter::pushValueSigned(
const Value *V,
unsigned InstID,
2226 int64_t diff = ((int32_t)InstID - (int32_t)
ValID);
2231void DXILBitcodeWriter::writeInstruction(
const Instruction &
I,
unsigned InstID,
2234 unsigned AbbrevToUse = 0;
2236 switch (
I.getOpcode()) {
2240 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2241 AbbrevToUse = (
unsigned)FUNCTION_INST_CAST_ABBREV;
2245 assert(isa<BinaryOperator>(
I) &&
"Unknown instruction!");
2247 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2248 AbbrevToUse = (
unsigned)FUNCTION_INST_BINOP_ABBREV;
2249 pushValue(
I.getOperand(1), InstID, Vals);
2253 if (AbbrevToUse == (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2254 AbbrevToUse = (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV;
2260 case Instruction::GetElementPtr: {
2262 AbbrevToUse = (
unsigned)FUNCTION_INST_GEP_ABBREV;
2263 auto &GEPInst = cast<GetElementPtrInst>(
I);
2265 Vals.
push_back(getTypeID(GEPInst.getSourceElementType()));
2266 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i)
2267 pushValueAndType(
I.getOperand(i), InstID, Vals);
2270 case Instruction::ExtractValue: {
2272 pushValueAndType(
I.getOperand(0), InstID, Vals);
2277 case Instruction::InsertValue: {
2279 pushValueAndType(
I.getOperand(0), InstID, Vals);
2280 pushValueAndType(
I.getOperand(1), InstID, Vals);
2285 case Instruction::Select:
2287 pushValueAndType(
I.getOperand(1), InstID, Vals);
2288 pushValue(
I.getOperand(2), InstID, Vals);
2289 pushValueAndType(
I.getOperand(0), InstID, Vals);
2291 case Instruction::ExtractElement:
2293 pushValueAndType(
I.getOperand(0), InstID, Vals);
2294 pushValueAndType(
I.getOperand(1), InstID, Vals);
2296 case Instruction::InsertElement:
2298 pushValueAndType(
I.getOperand(0), InstID, Vals);
2299 pushValue(
I.getOperand(1), InstID, Vals);
2300 pushValueAndType(
I.getOperand(2), InstID, Vals);
2302 case Instruction::ShuffleVector:
2304 pushValueAndType(
I.getOperand(0), InstID, Vals);
2305 pushValue(
I.getOperand(1), InstID, Vals);
2306 pushValue(cast<ShuffleVectorInst>(&
I)->getShuffleMaskForBitcode(), InstID,
2309 case Instruction::ICmp:
2310 case Instruction::FCmp: {
2313 pushValueAndType(
I.getOperand(0), InstID, Vals);
2314 pushValue(
I.getOperand(1), InstID, Vals);
2322 case Instruction::Ret: {
2324 unsigned NumOperands =
I.getNumOperands();
2325 if (NumOperands == 0)
2326 AbbrevToUse = (
unsigned)FUNCTION_INST_RET_VOID_ABBREV;
2327 else if (NumOperands == 1) {
2328 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2329 AbbrevToUse = (
unsigned)FUNCTION_INST_RET_VAL_ABBREV;
2331 for (
unsigned i = 0, e = NumOperands; i !=
e; ++i)
2332 pushValueAndType(
I.getOperand(i), InstID, Vals);
2335 case Instruction::Br: {
2339 if (
II.isConditional()) {
2341 pushValue(
II.getCondition(), InstID, Vals);
2344 case Instruction::Switch: {
2347 Vals.
push_back(getTypeID(
SI.getCondition()->getType()));
2348 pushValue(
SI.getCondition(), InstID, Vals);
2350 for (
auto Case :
SI.cases()) {
2355 case Instruction::IndirectBr:
2357 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2359 pushValue(
I.getOperand(0), InstID, Vals);
2360 for (
unsigned i = 1, e =
I.getNumOperands(); i != e; ++i)
2364 case Instruction::Invoke: {
2375 pushValueAndType(Callee, InstID, Vals);
2378 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2379 pushValue(
I.getOperand(i), InstID, Vals);
2382 if (FTy->isVarArg()) {
2383 for (
unsigned i = FTy->getNumParams(), e =
I.getNumOperands() - 3; i != e;
2385 pushValueAndType(
I.getOperand(i), InstID, Vals);
2389 case Instruction::Resume:
2391 pushValueAndType(
I.getOperand(0), InstID, Vals);
2393 case Instruction::Unreachable:
2395 AbbrevToUse = (
unsigned)FUNCTION_INST_UNREACHABLE_ABBREV;
2398 case Instruction::PHI: {
2399 const PHINode &PN = cast<PHINode>(
I);
2411 Stream.
EmitRecord(Code, Vals64, AbbrevToUse);
2416 case Instruction::LandingPad: {
2427 pushValueAndType(LP.
getClause(
I), InstID, Vals);
2432 case Instruction::Alloca: {
2436 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2439 assert(AlignRecord < 1 << 5 &&
"alignment greater than 1 << 64");
2441 AlignRecord |= 1 << 6;
2446 case Instruction::Load:
2447 if (cast<LoadInst>(
I).isAtomic()) {
2449 pushValueAndType(
I.getOperand(0), InstID, Vals);
2452 if (!pushValueAndType(
I.getOperand(0), InstID, Vals))
2453 AbbrevToUse = (
unsigned)FUNCTION_INST_LOAD_ABBREV;
2457 Vals.
push_back(cast<LoadInst>(
I).isVolatile());
2458 if (cast<LoadInst>(
I).isAtomic()) {
2460 Vals.
push_back(getEncodedSyncScopeID(cast<LoadInst>(
I).getSyncScopeID()));
2463 case Instruction::Store:
2464 if (cast<StoreInst>(
I).isAtomic())
2468 pushValueAndType(
I.getOperand(1), InstID, Vals);
2469 pushValueAndType(
I.getOperand(0), InstID, Vals);
2471 Vals.
push_back(cast<StoreInst>(
I).isVolatile());
2472 if (cast<StoreInst>(
I).isAtomic()) {
2475 getEncodedSyncScopeID(cast<StoreInst>(
I).getSyncScopeID()));
2478 case Instruction::AtomicCmpXchg:
2480 pushValueAndType(
I.getOperand(0), InstID, Vals);
2481 pushValueAndType(
I.getOperand(1), InstID, Vals);
2482 pushValue(
I.getOperand(2), InstID, Vals);
2483 Vals.
push_back(cast<AtomicCmpXchgInst>(
I).isVolatile());
2487 getEncodedSyncScopeID(cast<AtomicCmpXchgInst>(
I).getSyncScopeID()));
2490 Vals.
push_back(cast<AtomicCmpXchgInst>(
I).isWeak());
2492 case Instruction::AtomicRMW:
2494 pushValueAndType(
I.getOperand(0), InstID, Vals);
2495 pushValue(
I.getOperand(1), InstID, Vals);
2498 Vals.
push_back(cast<AtomicRMWInst>(
I).isVolatile());
2501 getEncodedSyncScopeID(cast<AtomicRMWInst>(
I).getSyncScopeID()));
2503 case Instruction::Fence:
2506 Vals.
push_back(getEncodedSyncScopeID(cast<FenceInst>(
I).getSyncScopeID()));
2508 case Instruction::Call: {
2521 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
2523 if (FTy->getParamType(i)->isLabelTy())
2530 if (FTy->isVarArg()) {
2531 for (
unsigned i = FTy->getNumParams(), e = CI.
arg_size(); i != e; ++i)
2536 case Instruction::VAArg:
2538 Vals.
push_back(getTypeID(
I.getOperand(0)->getType()));
2539 pushValue(
I.getOperand(0), InstID, Vals);
2549void DXILBitcodeWriter::writeFunctionLevelValueSymbolTable(
2562 for (
auto &VI : VST) {
2567 return A->first() <
B->first();
2570 for (
const ValueName *SI : SortedTable) {
2575 bool isChar6 =
true;
2576 for (
const char *
C =
Name.getKeyData(), *E =
C +
Name.getKeyLength();
2580 if ((
unsigned char)*
C & 128) {
2586 unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
2591 if (isa<BasicBlock>(
SI->getValue())) {
2594 AbbrevToUse = VST_BBENTRY_6_ABBREV;
2598 AbbrevToUse = VST_ENTRY_6_ABBREV;
2600 AbbrevToUse = VST_ENTRY_7_ABBREV;
2604 for (
const char *
P =
Name.getKeyData(),
2605 *E =
Name.getKeyData() +
Name.getKeyLength();
2610 Stream.
EmitRecord(Code, NameVals, AbbrevToUse);
2617void DXILBitcodeWriter::writeFunction(
const Function &
F) {
2630 unsigned CstStart, CstEnd;
2632 writeConstants(CstStart, CstEnd,
false);
2635 writeFunctionMetadata(
F);
2638 unsigned InstID = CstEnd;
2640 bool NeedsMetadataAttachment =
F.hasMetadata();
2648 writeInstruction(*
I, InstID, Vals);
2650 if (!
I->getType()->isVoidTy())
2654 NeedsMetadataAttachment |=
I->hasMetadataOtherThanDebugLoc();
2678 if (
auto *Symtab =
F.getValueSymbolTable())
2679 writeFunctionLevelValueSymbolTable(*Symtab);
2681 if (NeedsMetadataAttachment)
2682 writeFunctionMetadataAttachment(
F);
2689void DXILBitcodeWriter::writeBlockInfo() {
2696 auto Abbv = std::make_shared<BitCodeAbbrev>();
2702 std::move(Abbv)) != VST_ENTRY_8_ABBREV)
2703 assert(
false &&
"Unexpected abbrev ordering!");
2707 auto Abbv = std::make_shared<BitCodeAbbrev>();
2713 std::move(Abbv)) != VST_ENTRY_7_ABBREV)
2714 assert(
false &&
"Unexpected abbrev ordering!");
2717 auto Abbv = std::make_shared<BitCodeAbbrev>();
2723 std::move(Abbv)) != VST_ENTRY_6_ABBREV)
2724 assert(
false &&
"Unexpected abbrev ordering!");
2727 auto Abbv = std::make_shared<BitCodeAbbrev>();
2733 std::move(Abbv)) != VST_BBENTRY_6_ABBREV)
2734 assert(
false &&
"Unexpected abbrev ordering!");
2738 auto Abbv = std::make_shared<BitCodeAbbrev>();
2743 CONSTANTS_SETTYPE_ABBREV)
2744 assert(
false &&
"Unexpected abbrev ordering!");
2748 auto Abbv = std::make_shared<BitCodeAbbrev>();
2752 CONSTANTS_INTEGER_ABBREV)
2753 assert(
false &&
"Unexpected abbrev ordering!");
2757 auto Abbv = std::make_shared<BitCodeAbbrev>();
2765 CONSTANTS_CE_CAST_Abbrev)
2766 assert(
false &&
"Unexpected abbrev ordering!");
2769 auto Abbv = std::make_shared<BitCodeAbbrev>();
2772 CONSTANTS_NULL_Abbrev)
2773 assert(
false &&
"Unexpected abbrev ordering!");
2779 auto Abbv = std::make_shared<BitCodeAbbrev>();
2787 (
unsigned)FUNCTION_INST_LOAD_ABBREV)
2788 assert(
false &&
"Unexpected abbrev ordering!");
2791 auto Abbv = std::make_shared<BitCodeAbbrev>();
2797 (
unsigned)FUNCTION_INST_BINOP_ABBREV)
2798 assert(
false &&
"Unexpected abbrev ordering!");
2801 auto Abbv = std::make_shared<BitCodeAbbrev>();
2808 (
unsigned)FUNCTION_INST_BINOP_FLAGS_ABBREV)
2809 assert(
false &&
"Unexpected abbrev ordering!");
2812 auto Abbv = std::make_shared<BitCodeAbbrev>();
2819 (
unsigned)FUNCTION_INST_CAST_ABBREV)
2820 assert(
false &&
"Unexpected abbrev ordering!");
2824 auto Abbv = std::make_shared<BitCodeAbbrev>();
2827 (
unsigned)FUNCTION_INST_RET_VOID_ABBREV)
2828 assert(
false &&
"Unexpected abbrev ordering!");
2831 auto Abbv = std::make_shared<BitCodeAbbrev>();
2835 (
unsigned)FUNCTION_INST_RET_VAL_ABBREV)
2836 assert(
false &&
"Unexpected abbrev ordering!");
2839 auto Abbv = std::make_shared<BitCodeAbbrev>();
2842 (
unsigned)FUNCTION_INST_UNREACHABLE_ABBREV)
2843 assert(
false &&
"Unexpected abbrev ordering!");
2846 auto Abbv = std::make_shared<BitCodeAbbrev>();
2854 (
unsigned)FUNCTION_INST_GEP_ABBREV)
2855 assert(
false &&
"Unexpected abbrev ordering!");
2861void DXILBitcodeWriter::writeModuleVersion() {
2876 DXILBitcodeWriter::writeModuleVersion();
2882 writeAttributeGroupTable();
2885 writeAttributeTable();
2897 writeModuleConstants();
2900 writeModuleMetadataKinds();
2903 writeModuleMetadata();
2908 writeFunctionLevelValueSymbolTable(M.getValueSymbolTable());
2912 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_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.
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.