50 if (!V->isUsedByMetadata())
60 for (
User *U : MDV->users())
61 if (
auto *DDI = dyn_cast<DbgDeclareInst>(U))
69 if (!V->isUsedByMetadata())
77 if (DVR->getType() == DbgVariableRecord::LocationType::Declare)
84 DbgVariableRecord::LocationType::Any>
90 if (!V->isUsedByMetadata())
103 auto AppendUsers = [&Ctx, &EncounteredIntrinsics,
104 &EncounteredDbgVariableRecords, &Result,
107 for (
User *U : MDV->users())
108 if (IntrinsicT *DVI = dyn_cast<IntrinsicT>(U))
109 if (EncounteredIntrinsics.
insert(DVI).second)
110 Result.push_back(DVI);
112 if (!DbgVariableRecords)
117 if (
Type == DbgVariableRecord::LocationType::Any ||
118 DVR->getType() ==
Type)
119 if (EncounteredDbgVariableRecords.
insert(DVR).second)
127 for (
Metadata *AL : L->getAllArgListUsers()) {
129 if (!DbgVariableRecords)
133 if (
Type == DbgVariableRecord::LocationType::Any ||
134 DVR->getType() ==
Type)
135 if (EncounteredDbgVariableRecords.
insert(DVR).second)
144 findDbgIntrinsics<DbgValueInst, DbgVariableRecord::LocationType::Value>(
145 DbgValues, V, DbgVariableRecords);
151 findDbgIntrinsics<DbgVariableIntrinsic, DbgVariableRecord::LocationType::Any>(
152 DbgUsers, V, DbgVariableRecords);
156 if (
auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
170 return DILocation::get(DII->
getContext(), 0, 0, Scope, InlinedAt);
182 return DILocation::get(DVR->
getContext(), 0, 0, Scope, InlinedAt);
199 for (
auto *
CU : M.debug_compile_units())
200 processCompileUnit(
CU);
201 for (
auto &
F : M.functions()) {
202 if (
auto *SP = cast_or_null<DISubprogram>(
F.getSubprogram()))
213 if (!addCompileUnit(
CU))
215 for (
auto *DIG :
CU->getGlobalVariables()) {
216 if (!addGlobalVariable(DIG))
218 auto *GV = DIG->getVariable();
219 processScope(GV->getScope());
220 processType(GV->getType());
222 for (
auto *ET :
CU->getEnumTypes())
224 for (
auto *RT :
CU->getRetainedTypes())
225 if (
auto *
T = dyn_cast<DIType>(RT))
229 for (
auto *
Import :
CU->getImportedEntities()) {
230 auto *Entity =
Import->getEntity();
231 if (
auto *
T = dyn_cast<DIType>(Entity))
233 else if (
auto *SP = dyn_cast<DISubprogram>(Entity))
235 else if (
auto *NS = dyn_cast<DINamespace>(Entity))
236 processScope(NS->getScope());
237 else if (
auto *M = dyn_cast<DIModule>(Entity))
238 processScope(M->getScope());
244 if (
auto *DVI = dyn_cast<DbgVariableIntrinsic>(&
I))
247 if (
auto DbgLoc =
I.getDebugLoc())
250 for (
const DbgRecord &DPR :
I.getDbgRecordRange())
257 processScope(Loc->getScope());
267void DebugInfoFinder::processType(
DIType *DT) {
271 if (
auto *ST = dyn_cast<DISubroutineType>(DT)) {
276 if (
auto *DCT = dyn_cast<DICompositeType>(DT)) {
277 processType(DCT->getBaseType());
279 if (
auto *
T = dyn_cast<DIType>(
D))
281 else if (
auto *SP = dyn_cast<DISubprogram>(
D))
286 if (
auto *DDT = dyn_cast<DIDerivedType>(DT)) {
287 processType(DDT->getBaseType());
291void DebugInfoFinder::processScope(
DIScope *Scope) {
294 if (
auto *Ty = dyn_cast<DIType>(Scope)) {
298 if (
auto *
CU = dyn_cast<DICompileUnit>(Scope)) {
302 if (
auto *SP = dyn_cast<DISubprogram>(Scope)) {
306 if (!addScope(Scope))
308 if (
auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
309 processScope(LB->getScope());
310 }
else if (
auto *NS = dyn_cast<DINamespace>(Scope)) {
311 processScope(NS->getScope());
312 }
else if (
auto *M = dyn_cast<DIModule>(Scope)) {
313 processScope(
M->getScope());
318 if (!addSubprogram(SP))
329 processCompileUnit(SP->getUnit());
330 processType(SP->getType());
331 for (
auto *Element : SP->getTemplateParams()) {
332 if (
auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
333 processType(TType->getType());
334 }
else if (
auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
335 processType(TVal->getType());
342 if (!NodesSeen.insert(DV).second)
348bool DebugInfoFinder::addType(
DIType *DT) {
352 if (!NodesSeen.insert(DT).second)
355 TYs.push_back(
const_cast<DIType *
>(DT));
362 if (!NodesSeen.insert(
CU).second)
370 if (!NodesSeen.insert(DIG).second)
381 if (!NodesSeen.insert(SP).second)
388bool DebugInfoFinder::addScope(
DIScope *Scope) {
393 if (
Scope->getNumOperands() == 0)
395 if (!NodesSeen.insert(Scope).second)
397 Scopes.push_back(Scope);
404 "Loop ID needs at least one operand");
406 "Loop ID should refer to itself");
415 else if (
Metadata *NewMD = Updater(MD))
427 MDNode *OrigLoopID =
I.getMetadata(LLVMContext::MD_loop);
431 I.setMetadata(LLVMContext::MD_loop, NewLoopID);
439 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
442 if (isa<DILocation>(
N) || Reachable.
count(
N))
446 for (
auto &OpIt :
N->operands()) {
454 return Reachable.
count(
N);
461 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
464 if (isa<DILocation>(
N) || AllDILocation.
count(
N))
466 if (!DIReachable.
count(
N))
470 for (
auto &OpIt :
N->operands()) {
485 if (isa<DILocation>(MD) || AllDILocation.
count(MD))
488 if (!DIReachable.
count(MD))
491 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
496 bool HasSelfRef =
false;
497 for (
unsigned i = 0; i <
N->getNumOperands(); ++i) {
500 Args.push_back(
nullptr);
501 }
else if (
A == MD) {
502 assert(i == 0 &&
"expected i==0 for self-reference");
504 Args.push_back(
nullptr);
507 Args.push_back(NewArg);
510 if (Args.empty() || (HasSelfRef && Args.size() == 1))
521 assert(!
N->operands().empty() &&
"Missing self reference?");
532 [&Visited, &DILocationReachable](
const MDOperand &
Op) {
533 return isDILocationReachable(
534 Visited, DILocationReachable, Op.get());
542 [&Visited, &AllDILocation,
544 return isAllDILocation(Visited, AllDILocation,
545 DILocationReachable, Op.get());
556 bool Changed =
false;
557 if (
F.hasMetadata(LLVMContext::MD_dbg)) {
559 F.setSubprogram(
nullptr);
565 if (isa<DbgInfoIntrinsic>(&
I)) {
570 if (
I.getDebugLoc()) {
574 if (
auto *LoopID =
I.getMetadata(LLVMContext::MD_loop)) {
575 auto *NewLoopID = LoopIDsMap.
lookup(LoopID);
578 if (NewLoopID != LoopID)
579 I.setMetadata(LLVMContext::MD_loop, NewLoopID);
582 if (
I.hasMetadataOtherThanDebugLoc()) {
584 I.setMetadata(
"heapallocsite",
nullptr);
586 I.setMetadata(LLVMContext::MD_DIAssignID,
nullptr);
595 bool Changed =
false;
600 if (NMD.getName().starts_with(
"llvm.dbg.") ||
601 NMD.getName() ==
"llvm.gcov") {
602 NMD.eraseFromParent();
610 for (
auto &GV : M.globals()) {
611 Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
615 Materializer->setStripDebugInfo();
623class DebugTypeInfoRemoval {
628 MDNode *EmptySubroutineType;
652 auto Replacement = Replacements.find(M);
653 if (Replacement != Replacements.end())
654 return Replacement->second;
662 void traverseAndRemap(
MDNode *
N) { traverse(
N); }
667 auto *FileAndScope = cast_or_null<DIFile>(map(MDS->
getFile()));
670 auto *
Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
672 cast_or_null<DIType>(map(MDS->getContainingType()));
673 auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
674 auto Variables =
nullptr;
675 auto TemplateParams =
nullptr;
678 auto distinctMDSubprogram = [&]() {
679 return DISubprogram::getDistinct(
681 FileAndScope, MDS->getLine(),
Type, MDS->getScopeLine(),
682 ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
683 MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
688 return distinctMDSubprogram();
690 auto *NewMDS = DISubprogram::get(
692 FileAndScope, MDS->getLine(),
Type, MDS->getScopeLine(), ContainingType,
693 MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
694 MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
696 StringRef OldLinkageName = MDS->getLinkageName();
699 auto OrigLinkage = NewToLinkageName.find(NewMDS);
700 if (OrigLinkage != NewToLinkageName.end()) {
701 if (OrigLinkage->second == OldLinkageName)
707 return distinctMDSubprogram();
710 NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
720 auto *
File = cast_or_null<DIFile>(map(
CU->getFile()));
722 MDTuple *RetainedTypes =
nullptr;
723 MDTuple *GlobalVariables =
nullptr;
724 MDTuple *ImportedEntities =
nullptr;
725 return DICompileUnit::getDistinct(
726 CU->getContext(),
CU->getSourceLanguage(), File,
CU->getProducer(),
727 CU->isOptimized(),
CU->getFlags(),
CU->getRuntimeVersion(),
729 RetainedTypes, GlobalVariables, ImportedEntities,
CU->getMacros(),
730 CU->getDWOId(),
CU->getSplitDebugInlining(),
731 CU->getDebugInfoForProfiling(),
CU->getNameTableKind(),
732 CU->getRangesBaseAddress(),
CU->getSysRoot(),
CU->getSDK());
736 auto *
Scope = map(MLD->getScope());
737 auto *InlinedAt = map(MLD->getInlinedAt());
739 return DILocation::getDistinct(MLD->
getContext(), MLD->getLine(),
740 MLD->getColumn(), Scope, InlinedAt);
741 return DILocation::get(MLD->
getContext(), MLD->getLine(), MLD->getColumn(),
749 for (
auto &
I :
N->operands())
758 if (Replacements.count(
N))
764 if (
auto *MDSub = dyn_cast<DISubprogram>(
N)) {
765 remap(MDSub->getUnit());
766 return getReplacementSubprogram(MDSub);
768 if (isa<DISubroutineType>(
N))
769 return EmptySubroutineType;
770 if (
auto *
CU = dyn_cast<DICompileUnit>(
N))
771 return getReplacementCU(
CU);
774 if (
auto *MDLB = dyn_cast<DILexicalBlockBase>(
N))
776 return mapNode(MDLB->getScope());
777 if (
auto *MLD = dyn_cast<DILocation>(
N))
778 return getReplacementMDLocation(MLD);
785 return getReplacementMDNode(
N);
787 Replacements[
N] = doRemap(
N);
796void DebugTypeInfoRemoval::traverse(
MDNode *
N) {
797 if (!
N || Replacements.count(
N))
803 if (
auto *MDS = dyn_cast<DISubprogram>(Parent))
804 return Child == MDS->getRetainedNodes().
get();
813 while (!ToVisit.
empty()) {
814 auto *
N = ToVisit.
back();
815 if (!Opened.
insert(
N).second) {
821 for (
auto &
I :
N->operands())
822 if (
auto *MDN = dyn_cast_or_null<MDNode>(
I))
823 if (!Opened.
count(MDN) && !Replacements.count(MDN) && !
prune(
N, MDN) &&
824 !isa<DICompileUnit>(MDN))
830 bool Changed =
false;
834 if (
auto *DbgVal = M.getFunction(
Name)) {
835 while (!DbgVal->use_empty())
836 cast<Instruction>(DbgVal->user_back())->eraseFromParent();
837 DbgVal->eraseFromParent();
841 RemoveUses(
"llvm.dbg.declare");
842 RemoveUses(
"llvm.dbg.label");
843 RemoveUses(
"llvm.dbg.value");
846 for (
auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
851 if (NMD->
getName() ==
"llvm.dbg.cu")
856 for (
auto &GV : M.globals())
857 GV.eraseMetadata(LLVMContext::MD_dbg);
859 DebugTypeInfoRemoval Mapper(M.getContext());
863 Mapper.traverseAndRemap(Node);
864 auto *NewNode = Mapper.mapNode(Node);
865 Changed |= Node != NewNode;
873 if (
auto *SP =
F.getSubprogram()) {
874 Mapper.traverseAndRemap(SP);
875 auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
876 Changed |= SP != NewSP;
877 F.setSubprogram(NewSP);
882 auto *Scope =
DL.getScope();
883 MDNode *InlinedAt =
DL.getInlinedAt();
884 Scope = remap(Scope);
885 InlinedAt = remap(InlinedAt);
891 I.setDebugLoc(remapDebugLoc(
I.getDebugLoc()));
895 if (
auto *Loc = dyn_cast_or_null<DILocation>(MD))
896 return remapDebugLoc(Loc).
get();
901 if (
I.hasMetadataOtherThanDebugLoc())
902 I.setMetadata(
"heapallocsite",
nullptr);
912 for (
auto &NMD : M.named_metadata()) {
929 if (
auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
930 M.getModuleFlag(
"Debug Info Version")))
931 return Val->getZExtValue();
947 if (
auto *MD =
I->getMetadata(LLVMContext::MD_DIAssignID))
950 "Merging with instruction from another function not allowed");
954 if (
auto *MD =
getMetadata(LLVMContext::MD_DIAssignID))
961 for (
auto It = std::next(IDs.
begin()),
End = IDs.
end(); It !=
End; ++It) {
977 bool MayLowerToCall =
false;
978 if (isa<CallBase>(
this)) {
979 auto *II = dyn_cast<IntrinsicInst>(
this);
984 if (!MayLowerToCall) {
1013#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
1014 case LLVMDWARFSourceLanguage##NAME: \
1016#include "llvm/BinaryFormat/Dwarf.def"
1017#undef HANDLE_DW_LANG
1023 return (DIT *)(
Ref ? unwrap<MDNode>(
Ref) :
nullptr);
1064 unwrap(Builder)->finalize();
1069 unwrap(Builder)->finalizeSubprogram(unwrapDI<DISubprogram>(subprogram));
1075 LLVMBool isOptimized,
const char *Flags,
size_t FlagsLen,
1076 unsigned RuntimeVer,
const char *SplitName,
size_t SplitNameLen,
1078 LLVMBool DebugInfoForProfiling,
const char *SysRoot,
size_t SysRootLen,
1079 const char *SDK,
size_t SDKLen) {
1080 auto File = unwrapDI<DIFile>(FileRef);
1082 return wrap(
unwrap(Builder)->createCompileUnit(
1085 RuntimeVer,
StringRef(SplitName, SplitNameLen),
1087 SplitDebugInlining, DebugInfoForProfiling,
1094 size_t FilenameLen,
const char *Directory,
1095 size_t DirectoryLen) {
1102 const char *
Name,
size_t NameLen,
1103 const char *ConfigMacros,
size_t ConfigMacrosLen,
1104 const char *IncludePath,
size_t IncludePathLen,
1105 const char *APINotesFile,
size_t APINotesFileLen) {
1108 StringRef(ConfigMacros, ConfigMacrosLen),
1110 StringRef(APINotesFile, APINotesFileLen)));
1115 const char *
Name,
size_t NameLen,
1117 return wrap(
unwrap(Builder)->createNameSpace(
1118 unwrapDI<DIScope>(ParentScope),
StringRef(
Name, NameLen), ExportSymbols));
1123 size_t NameLen,
const char *
LinkageName,
size_t LinkageNameLen,
1128 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {
LinkageName, LinkageNameLen},
1129 unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
1139 return wrap(
unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
1140 unwrapDI<DIFile>(File),
1148 unsigned Discriminator) {
1149 return wrap(
unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
1150 unwrapDI<DIFile>(File),
1161 unwrapDI<DINamespace>(NS),
1162 unwrapDI<DIFile>(File),
1172 ?
unwrap(Builder)->getOrCreateArray({
unwrap(Elements), NumElements})
1175 unwrapDI<DIScope>(Scope), unwrapDI<DIImportedEntity>(ImportedEntity),
1176 unwrapDI<DIFile>(File), Line, Elts));
1182 unsigned NumElements) {
1185 ?
unwrap(Builder)->getOrCreateArray({
unwrap(Elements), NumElements})
1188 unwrapDI<DIScope>(Scope), unwrapDI<DIModule>(M), unwrapDI<DIFile>(File),
1198 ?
unwrap(Builder)->getOrCreateArray({
unwrap(Elements), NumElements})
1200 return wrap(
unwrap(Builder)->createImportedDeclaration(
1201 unwrapDI<DIScope>(Scope), unwrapDI<DINode>(Decl), unwrapDI<DIFile>(File),
1202 Line, {
Name, NameLen}, Elts));
1214 return unwrapDI<DILocation>(Location)->getLine();
1218 return unwrapDI<DILocation>(Location)->getColumn();
1222 return wrap(unwrapDI<DILocation>(Location)->
getScope());
1226 return wrap(unwrapDI<DILocation>(Location)->getInlinedAt());
1230 return wrap(unwrapDI<DIScope>(Scope)->getFile());
1234 auto Dir = unwrapDI<DIFile>(File)->getDirectory();
1240 auto Name = unwrapDI<DIFile>(File)->getFilename();
1246 if (
auto Src = unwrapDI<DIFile>(File)->getSource()) {
1258 const char *
Name,
size_t NameLen,
1259 const char *
Value,
size_t ValueLen) {
1261 unwrap(Builder)->createMacro(unwrapDI<DIMacroFile>(ParentMacroFile), Line,
1270 return wrap(
unwrap(Builder)->createTempMacroFile(
1271 unwrapDI<DIMacroFile>(ParentMacroFile), Line, unwrapDI<DIFile>(File)));
1275 const char *
Name,
size_t NameLen,
1287auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1289return wrap(
unwrap(Builder)->createEnumerationType(
1290 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1291 LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
1298 LLVMMetadataRef *Elements,
unsigned NumElements,
unsigned RunTimeLang,
1299 const char *UniqueId,
size_t UniqueIdLen) {
1300 auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1302 return wrap(
unwrap(Builder)->createUnionType(
1303 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1305 Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
1313 unsigned NumSubscripts) {
1314 auto Subs =
unwrap(Builder)->getOrCreateArray({
unwrap(Subscripts),
1317 unwrapDI<DIType>(Ty), Subs));
1324 unsigned NumSubscripts) {
1325 auto Subs =
unwrap(Builder)->getOrCreateArray({
unwrap(Subscripts),
1328 unwrapDI<DIType>(Ty), Subs));
1333 size_t NameLen,
uint64_t SizeInBits,
1337 SizeInBits, Encoding,
1344 const char *
Name,
size_t NameLen) {
1345 return wrap(
unwrap(Builder)->createPointerType(
1346 unwrapDI<DIType>(PointeeTy), SizeInBits, AlignInBits,
AddressSpace,
1355 unsigned NumElements,
unsigned RunTimeLang,
LLVMMetadataRef VTableHolder,
1356 const char *UniqueId,
size_t UniqueIdLen) {
1357 auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1359 return wrap(
unwrap(Builder)->createStructType(
1360 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1362 unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
1363 unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
1371 return wrap(
unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
1372 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
1379 return wrap(
unwrap(Builder)->createUnspecifiedType({
Name, NameLen}));
1387 return wrap(
unwrap(Builder)->createStaticMemberType(
1388 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1390 unwrap<Constant>(ConstantVal), DW_TAG_member, AlignInBits));
1395 const char *
Name,
size_t NameLen,
1401 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1402 SizeInBits, AlignInBits, OffsetInBits,
1404 unwrapDI<MDNode>(PropertyNode)));
1409 const char *
Name,
size_t NameLen,
1411 const char *GetterName,
size_t GetterNameLen,
1412 const char *SetterName,
size_t SetterNameLen,
1413 unsigned PropertyAttributes,
1415 return wrap(
unwrap(Builder)->createObjCProperty(
1416 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1417 {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1418 PropertyAttributes, unwrapDI<DIType>(Ty)));
1424 return wrap(
unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(
Type)));
1429 const char *
Name,
size_t NameLen,
1433 unwrapDI<DIType>(
Type), {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1434 unwrapDI<DIScope>(Scope), AlignInBits));
1442 return wrap(
unwrap(Builder)->createInheritance(
1443 unwrapDI<DIType>(Ty), unwrapDI<DIType>(
BaseTy),
1452 const char *UniqueIdentifier,
size_t UniqueIdentifierLen) {
1453 return wrap(
unwrap(Builder)->createForwardDecl(
1454 Tag, {
Name, NameLen}, unwrapDI<DIScope>(Scope),
1455 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1456 AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1465 size_t UniqueIdentifierLen) {
1466 return wrap(
unwrap(Builder)->createReplaceableCompositeType(
1467 Tag, {
Name, NameLen}, unwrapDI<DIScope>(Scope),
1468 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1470 {UniqueIdentifier, UniqueIdentifierLen}));
1477 unwrapDI<DIType>(
Type)));
1484 unwrapDI<DIType>(
Type)));
1489 return wrap(
unwrap(Builder)->createNullPtrType());
1499 return wrap(
unwrap(Builder)->createMemberPointerType(
1500 unwrapDI<DIType>(PointeeType),
1501 unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1508 const char *
Name,
size_t NameLen,
1514 return wrap(
unwrap(Builder)->createBitFieldMemberType(
1515 unwrapDI<DIScope>(Scope), {
Name, NameLen},
1516 unwrapDI<DIFile>(File), LineNumber,
1517 SizeInBits, OffsetInBits, StorageOffsetInBits,
1528 const char *UniqueIdentifier,
size_t UniqueIdentifierLen) {
1529 auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1531 return wrap(
unwrap(Builder)->createClassType(
1532 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1533 LineNumber, SizeInBits, AlignInBits, OffsetInBits,
1535 0, unwrapDI<DIType>(VTableHolder),
1536 unwrapDI<MDNode>(TemplateParamsNode),
1537 {UniqueIdentifier, UniqueIdentifierLen}));
1543 return wrap(
unwrap(Builder)->createArtificialType(unwrapDI<DIType>(
Type)));
1547 return unwrapDI<DINode>(MD)->getTag();
1551 StringRef Str = unwrapDI<DIType>(DType)->getName();
1557 return unwrapDI<DIType>(DType)->getSizeInBits();
1561 return unwrapDI<DIType>(DType)->getOffsetInBits();
1565 return unwrapDI<DIType>(DType)->getAlignInBits();
1569 return unwrapDI<DIType>(DType)->getLine();
1587 unsigned NumParameterTypes,
1589 auto Elts =
unwrap(Builder)->getOrCreateTypeArray({
unwrap(ParameterTypes),
1590 NumParameterTypes});
1591 return wrap(
unwrap(Builder)->createSubroutineType(
1609 size_t NameLen,
const char *Linkage,
size_t LinkLen,
LLVMMetadataRef File,
1612 return wrap(
unwrap(Builder)->createGlobalVariableExpression(
1613 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {Linkage, LinkLen},
1614 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1615 true, unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1616 nullptr, AlignInBits));
1620 return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getVariable());
1625 return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getExpression());
1629 return wrap(unwrapDI<DIVariable>(Var)->getFile());
1637 return unwrapDI<DIVariable>(Var)->getLine();
1652 auto *
Node = unwrapDI<MDNode>(TargetMetadata);
1653 Node->replaceAllUsesWith(
unwrap(Replacement));
1659 size_t NameLen,
const char *Linkage,
size_t LnkLen,
LLVMMetadataRef File,
1662 return wrap(
unwrap(Builder)->createTempGlobalVariableFwdDecl(
1663 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {Linkage, LnkLen},
1664 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1665 unwrapDI<MDNode>(Decl),
nullptr, AlignInBits));
1679 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1680 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
1681 unwrap<Instruction>(Instr));
1687 assert(isa<Instruction *>(DbgInst) &&
1688 "Function unexpectedly in new debug info format");
1689 return wrap(cast<Instruction *>(DbgInst));
1695 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1696 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
1697 unwrap<Instruction>(Instr));
1703 assert(isa<DbgRecord *>(DbgInst) &&
1704 "Function unexpectedly in old debug info format");
1705 return wrap(cast<DbgRecord *>(DbgInst));
1719 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1720 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
unwrap(
Block));
1726 assert(isa<Instruction *>(DbgInst) &&
1727 "Function unexpectedly in new debug info format");
1728 return wrap(cast<Instruction *>(DbgInst));
1734 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1735 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
unwrap(
Block));
1741 assert(isa<DbgRecord *>(DbgInst) &&
1742 "Function unexpectedly in old debug info format");
1743 return wrap(cast<DbgRecord *>(DbgInst));
1756 unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap<DIExpression>(Expr),
1757 unwrap<DILocation>(
DebugLoc), unwrap<Instruction>(Instr));
1763 assert(isa<Instruction *>(DbgInst) &&
1764 "Function unexpectedly in new debug info format");
1765 return wrap(cast<Instruction *>(DbgInst));
1771 unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap<DIExpression>(Expr),
1772 unwrap<DILocation>(
DebugLoc), unwrap<Instruction>(Instr));
1778 assert(isa<DbgRecord *>(DbgInst) &&
1779 "Function unexpectedly in old debug info format");
1780 return wrap(cast<DbgRecord *>(DbgInst));
1793 unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap<DIExpression>(Expr),
1800 assert(isa<Instruction *>(DbgInst) &&
1801 "Function unexpectedly in new debug info format");
1802 return wrap(cast<Instruction *>(DbgInst));
1808 unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap<DIExpression>(Expr),
1815 assert(isa<DbgRecord *>(DbgInst) &&
1816 "Function unexpectedly in old debug info format");
1817 return wrap(cast<DbgRecord *>(DbgInst));
1824 return wrap(
unwrap(Builder)->createAutoVariable(
1825 unwrap<DIScope>(Scope), {
Name, NameLen}, unwrap<DIFile>(File),
1826 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1832 size_t NameLen,
unsigned ArgNo,
LLVMMetadataRef File,
unsigned LineNo,
1834 return wrap(
unwrap(Builder)->createParameterVariable(
1835 unwrap<DIScope>(Scope), {
Name, NameLen}, ArgNo, unwrap<DIFile>(File),
1836 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1841 int64_t
Lo, int64_t Count) {
1842 return wrap(
unwrap(Builder)->getOrCreateSubrange(
Lo, Count));
1857 unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1861 return unwrapDI<DISubprogram>(Subprogram)->getLine();
1870 unwrap<Instruction>(Inst)->setDebugLoc(
DebugLoc(unwrap<MDNode>(Loc)));
1872 unwrap<Instruction>(Inst)->setDebugLoc(
DebugLoc());
1877#define HANDLE_METADATA_LEAF(CLASS) \
1878 case Metadata::CLASS##Kind: \
1879 return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
1880#include "llvm/IR/Metadata.def"
1887 assert(
ID &&
"Expected non-null ID");
1891 auto MapIt = Map.find(
ID);
1892 if (MapIt == Map.end())
1895 return make_range(MapIt->second.begin(), MapIt->second.end());
1899 assert(
ID &&
"Expected non-null ID");
1909 return make_range(IDAsValue->user_begin(), IDAsValue->user_end());
1915 if (Range.empty() && DVRAssigns.
empty())
1918 for (
auto *DAI : ToDelete)
1919 DAI->eraseFromParent();
1920 for (
auto *DVR : DVRAssigns)
1921 DVR->eraseFromParent();
1931 for (
auto *
I : InstVec)
1932 I->setMetadata(LLVMContext::MD_DIAssignID, New);
1943 if (DVR.isDbgAssign())
1945 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(&
I))
1948 I.setMetadata(LLVMContext::MD_DIAssignID,
nullptr);
1951 for (
auto *DAI : ToDelete)
1952 DAI->eraseFromParent();
1953 for (
auto *DVR : DPToDelete)
1954 DVR->eraseFromParent();
1968 return VariableSlice;
1979 return VariableSlice;
1981template <
typename T>
1984 uint64_t SliceSizeInBits,
const T *AssignRecord,
1985 std::optional<DIExpression::FragmentInfo> &Result) {
2078 if (AssignRecord->isKillAddress())
2088 int64_t PointerOffsetInBits;
2090 auto DestOffsetInBytes =
2091 AssignRecord->getAddress()->getPointerOffsetFrom(Dest,
DL);
2092 if (!DestOffsetInBytes)
2095 int64_t ExprOffsetInBytes;
2096 if (!AssignRecord->getAddressExpression()->extractIfOffset(
2100 int64_t PointerOffsetInBytes = *DestOffsetInBytes + ExprOffsetInBytes;
2101 PointerOffsetInBits = PointerOffsetInBytes * 8;
2106 int64_t NewOffsetInBits =
2107 SliceOffsetInBits + VarFrag.
OffsetInBits - PointerOffsetInBits;
2108 if (NewOffsetInBits < 0)
2115 if (TrimmedSliceOfVariable == VarFrag)
2116 Result = std::nullopt;
2118 Result = TrimmedSliceOfVariable;
2124 std::optional<DIExpression::FragmentInfo> &Result) {
2126 SliceSizeInBits, DbgAssign, Result);
2131 std::optional<DIExpression::FragmentInfo> &Result) {
2133 SliceSizeInBits, DVRAssign, Result);
2139static std::optional<AssignmentInfo>
2143 return std::nullopt;
2144 APInt GEPOffset(
DL.getIndexTypeSizeInBits(StoreDest->
getType()), 0);
2146 DL, GEPOffset,
true);
2149 return std::nullopt;
2154 return std::nullopt;
2155 if (
const auto *Alloca = dyn_cast<AllocaInst>(
Base))
2157 return std::nullopt;
2162 const Value *StoreDest =
I->getRawDest();
2164 auto *ConstLengthInBytes = dyn_cast<ConstantInt>(
I->getLength());
2165 if (!ConstLengthInBytes)
2167 return std::nullopt;
2168 uint64_t SizeInBits = 8 * ConstLengthInBytes->getZExtValue();
2174 TypeSize SizeInBits =
DL.getTypeSizeInBits(SI->getValueOperand()->getType());
2188 auto *
ID = StoreLikeInst.
getMetadata(LLVMContext::MD_DIAssignID);
2189 assert(
ID &&
"Store instruction must have DIAssignID metadata");
2195 uint64_t FragStartBit = StoreStartBit;
2198 bool StoreToWholeVariable =
Info.StoreToWholeAlloca;
2207 FragEndBit = std::min(FragEndBit, VarEndBit);
2210 if (FragStartBit >= FragEndBit)
2213 StoreToWholeVariable = FragStartBit <= VarStartBit && FragEndBit >= *
Size;
2218 if (!StoreToWholeVariable) {
2220 FragEndBit - FragStartBit);
2221 assert(R.has_value() &&
"failed to create fragment expression");
2228 &StoreLikeInst, Val, VarRec.
Var, Expr, Dest, AddrExpr, VarRec.
DL);
2230 LLVM_DEBUG(
if (Assign)
errs() <<
" > INSERT: " << *Assign <<
"\n");
2234 AddrExpr, VarRec.
DL);
2237 if (Assign.is<DbgRecord *>())
2238 errs() <<
" > INSERT: " << *Assign.get<DbgRecord *>() <<
"\n";
2240 errs() <<
" > INSERT: " << *Assign.get<Instruction *>() <<
"\n";
2245#define DEBUG_TYPE "assignment-tracking"
2254 auto &Ctx = Start->getContext();
2255 auto &
Module = *Start->getModule();
2263 for (
auto BBI = Start; BBI !=
End; ++BBI) {
2266 std::optional<AssignmentInfo>
Info;
2267 Value *ValueComponent =
nullptr;
2268 Value *DestComponent =
nullptr;
2269 if (
auto *AI = dyn_cast<AllocaInst>(&
I)) {
2274 ValueComponent = Undef;
2276 }
else if (
auto *SI = dyn_cast<StoreInst>(&
I)) {
2278 ValueComponent = SI->getValueOperand();
2279 DestComponent = SI->getPointerOperand();
2280 }
else if (
auto *
MI = dyn_cast<MemTransferInst>(&
I)) {
2283 ValueComponent = Undef;
2284 DestComponent =
MI->getOperand(0);
2285 }
else if (
auto *
MI = dyn_cast<MemSetInst>(&
I)) {
2289 auto *ConstValue = dyn_cast<ConstantInt>(
MI->getOperand(1));
2290 if (ConstValue && ConstValue->isZero())
2291 ValueComponent = ConstValue;
2293 ValueComponent = Undef;
2294 DestComponent =
MI->getOperand(0);
2300 assert(ValueComponent && DestComponent);
2304 if (!
Info.has_value()) {
2307 <<
" | SKIP: Untrackable store (e.g. through non-const gep)\n");
2313 auto LocalIt = Vars.
find(
Info->Base);
2314 if (LocalIt == Vars.
end()) {
2317 <<
" | SKIP: Base address not associated with local variable\n");
2322 cast_or_null<DIAssignID>(
I.getMetadata(LLVMContext::MD_DIAssignID));
2325 I.setMetadata(LLVMContext::MD_DIAssignID,
ID);
2328 for (
const VarRecord &R : LocalIt->second)
2334bool AssignmentTrackingPass::runOnFunction(
Function &
F) {
2336 if (
F.hasFnAttribute(Attribute::OptimizeNone))
2339 bool Changed =
false;
2340 auto *
DL = &
F.getParent()->getDataLayout();
2349 auto ProcessDeclare = [&](
auto *Declare,
auto &DeclareList) {
2353 if (Declare->getExpression()->getNumElements() != 0)
2355 if (!Declare->getAddress())
2358 dyn_cast<AllocaInst>(Declare->getAddress()->stripPointerCasts())) {
2360 if (!Alloca->isStaticAlloca())
2363 if (
auto Sz = Alloca->getAllocationSize(*
DL); Sz && Sz->isScalable())
2365 DeclareList[Alloca].
insert(Declare);
2369 for (
auto &BB :
F) {
2370 for (
auto &
I : BB) {
2372 if (DVR.isDbgDeclare())
2373 ProcessDeclare(&DVR, DVRDeclares);
2376 ProcessDeclare(DDI, DbgDeclares);
2392 auto DeleteSubsumedDeclare = [&](
const auto &
Markers,
auto &Declares) {
2394 for (
auto *Declare : Declares) {
2408 Declare->eraseFromParent();
2412 for (
auto &
P : DbgDeclares)
2414 for (
auto &
P : DVRDeclares)
2420 "debug-info-assignment-tracking";
2430 return Value && !cast<ConstantAsMetadata>(
Value)->getValue()->isZeroValue();
2439 if (!runOnFunction(
F))
2456 bool Changed =
false;
2458 Changed |= runOnFunction(
F);
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Analysis containing CSE Info
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
static DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, DINodeArray Elements, SmallVectorImpl< TrackingMDNodeRef > &ImportedModules)
static void setAssignmentTrackingModuleFlag(Module &M)
static DISubprogram::DISPFlags pack_into_DISPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized)
static Metadata * stripLoopMDLoc(const SmallPtrSetImpl< Metadata * > &AllDILocation, const SmallPtrSetImpl< Metadata * > &DIReachable, Metadata *MD)
static MDNode * updateLoopMetadataDebugLocationsImpl(MDNode *OrigLoopID, function_ref< Metadata *(Metadata *)> Updater)
static MDNode * stripDebugLocFromLoopID(MDNode *N)
bool calculateFragmentIntersectImpl(const DataLayout &DL, const Value *Dest, uint64_t SliceOffsetInBits, uint64_t SliceSizeInBits, const T *AssignRecord, std::optional< DIExpression::FragmentInfo > &Result)
static const char * AssignmentTrackingModuleFlag
static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags)
static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang)
static void emitDbgAssign(AssignmentInfo Info, Value *Val, Value *Dest, Instruction &StoreLikeInst, const VarRecord &VarRec, DIBuilder &DIB)
Returns nullptr if the assignment shouldn't be attributed to this variable.
static DIExpression::FragmentInfo getFragmentOrEntireVariable(const DbgVariableRecord *DVR)
Get the FragmentInfo for the variable if it exists, otherwise return a FragmentInfo that covers the e...
static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags)
static void findDbgIntrinsics(SmallVectorImpl< IntrinsicT * > &Result, Value *V, SmallVectorImpl< DbgVariableRecord * > *DbgVariableRecords)
static bool getAssignmentTrackingModuleFlag(const Module &M)
static bool isAllDILocation(SmallPtrSetImpl< Metadata * > &Visited, SmallPtrSetImpl< Metadata * > &AllDILocation, const SmallPtrSetImpl< Metadata * > &DIReachable, Metadata *MD)
static bool isDILocationReachable(SmallPtrSetImpl< Metadata * > &Visited, SmallPtrSetImpl< Metadata * > &Reachable, Metadata *MD)
Return true if a node is a DILocation or if a DILocation is indirectly referenced by one of the node'...
DIT * unwrapDI(LLVMMetadataRef Ref)
static std::optional< AssignmentInfo > getAssignmentInfoImpl(const DataLayout &DL, const Value *StoreDest, TypeSize SizeInBits)
Collect constant properies (base, size, offset) of StoreDest.
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static SPIRV::Scope::Scope getScope(SyncScope::ID Ord, SPIRVMachineModuleInfo *MMI)
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
static uint32_t getFlags(const Symbol *Sym)
Class for arbitrary precision integers.
bool isNegative() const
Determine sign of this APInt.
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value.
an instruction to allocate memory on the stack
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
A container for analyses that lazily runs them and caches their results.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
LLVM Basic Block Representation.
bool IsNewDbgInfoFormat
Flag recording whether or not this block stores debug-info in the form of intrinsic instructions (fal...
Represents analyses that only rely on functions' control flow.
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
SmallVector< DbgVariableRecord * > getAllDbgVariableRecordUsers()
static DIAssignID * getDistinct(LLVMContext &Context)
DbgInstPtr insertDbgAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *SrcVar, DIExpression *ValExpr, Value *Addr, DIExpression *AddrExpr, const DILocation *DL)
Insert a new llvm.dbg.assign intrinsic call.
static std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
static std::optional< DIExpression * > createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits)
Create a DIExpression to describe one part of an aggregate variable that is fragmented across multipl...
A pair of DIGlobalVariable and DIExpression.
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
DILocalScope * getScope() const
Get the local scope for this variable.
static DILocation * getMergedLocation(DILocation *LocA, DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
Tagged DWARF-like metadata node.
Base class for scope-like contexts.
StringRef getName() const
DIScope * getScope() const
static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
DISPFlags
Debug info subprogram flags.
Type array for a subprogram.
DIScope * getScope() const
std::optional< uint64_t > getSizeInBits() const
Determines the size of the variable's type.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
This represents the llvm.dbg.assign instruction.
This represents the llvm.dbg.declare instruction.
Base class for non-instruction debug metadata records that have positions within IR.
DebugLoc getDebugLoc() const
LLVMContext & getContext()
This is the common base class for debug info intrinsics for variables.
std::optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
DIExpression * getExpression() const
Record of a variable value-assignment, aka a non instruction representation of the dbg....
std::optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
DIExpression * getExpression() const
static DbgVariableRecord * createLinkedDVRAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *Variable, DIExpression *Expression, Value *Address, DIExpression *AddressExpression, const DILocation *DI)
void processInstruction(const Module &M, const Instruction &I)
Process a single instruction and collect debug info anchors.
void processModule(const Module &M)
Process entire module and collect debug info anchors.
void processVariable(const Module &M, const DILocalVariable *DVI)
Process a DILocalVariable.
void processSubprogram(DISubprogram *SP)
Process subprogram.
void processLocation(const Module &M, const DILocation *Loc)
Process debug info location.
void reset()
Clear all lists.
void processDbgRecord(const Module &M, const DbgRecord &DR)
Process a DbgRecord (e.g, treat a DbgVariableRecord like a DbgVariableIntrinsic).
DILocation * get() const
Get the underlying DILocation.
MDNode * getScope() const
DILocation * getInlinedAt() const
Identifies a unique instance of a whole variable (discards/ignores fragment information).
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Implements a dense probed hash-table based set.
BasicBlockListType::iterator iterator
DISubprogram * getSubprogram() const
Get the attached subprogram.
void mergeDIAssignID(ArrayRef< const Instruction * > SourceInstructions)
Merge the DIAssignID metadata from this instruction and those attached to instructions in SourceInstr...
void dropLocation()
Drop the instruction's debug location.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
const BasicBlock * getParent() const
const Function * getFunction() const
Return the function this instruction belongs to.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
void updateLocationAfterHoist()
Updates the debug location given that the instruction has been hoisted from a block to a predecessor ...
void applyMergedLocation(DILocation *LocA, DILocation *LocB)
Merge 2 debug locations and apply it to the Instruction.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
static bool mayLowerToFunctionCall(Intrinsic::ID IID)
Check if the intrinsic might lower into a regular function call in the course of IR transformations.
DenseMap< DIAssignID *, SmallVector< Instruction *, 1 > > AssignmentIDToInstrs
Map DIAssignID -> Instructions with that attachment.
This is an important class for using LLVM in a threaded context.
LLVMContextImpl *const pImpl
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
void replaceAllUsesWith(Metadata *MD)
RAUW a temporary.
static void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
const MDOperand & getOperand(unsigned I) const
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
unsigned getNumOperands() const
Return number of MDNode operands.
LLVMContext & getContext() const
Tracking metadata reference owned by Metadata.
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
This is the common base class for memset/memcpy/memmove.
A Module instance is used to store all the information related to an LLVM module.
@ Max
Takes the max of the two values, which are required to be integers.
StringRef getName() const
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void preserveSet()
Mark an analysis set as preserved.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
void push_back(EltTy NewVal)
static constexpr TypeSize getFixed(ScalarTy ExactSize)
The instances of the Type class are immutable: once they are created, they are never changed.
static IntegerType * getInt1Ty(LLVMContext &C)
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr) const
Accumulate the constant offset this value has compared to a base pointer.
LLVMContext & getContext() const
All values hold a context through their type.
user_iterator_impl< User > user_iterator
std::pair< iterator, bool > insert(const ValueT &V)
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
An efficient, type-erasing, non-owning reference to a callable.
A range adaptor for a pair of iterators.
LLVMMetadataRef LLVMDIBuilderCreateObjCIVar(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef Ty, LLVMMetadataRef PropertyNode)
Create debugging information entry for Objective-C instance variable.
LLVMMetadataRef LLVMDILocationGetInlinedAt(LLVMMetadataRef Location)
Get the "inline at" location associated with this debug location.
LLVMDbgRecordRef LLVMDIBuilderInsertDeclareBefore(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Data, size_t NumElements)
Create an array of DI Nodes.
LLVMMetadataRef LLVMDIBuilderCreateEnumerationType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, LLVMMetadataRef *Elements, unsigned NumElements, LLVMMetadataRef ClassTy)
Create debugging information entry for an enumeration.
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef M, LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements, unsigned NumElements)
Create a descriptor for an imported module.
LLVMMetadataRef LLVMDIBuilderCreateObjectPointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagObjectPointer and FlagArtificial set.
uint64_t LLVMDITypeGetSizeInBits(LLVMMetadataRef DType)
Get the size of this DIType in bits.
LLVMDWARFMacinfoRecordType
Describes the kind of macro declaration used for LLVMDIBuilderCreateMacro.
LLVMMetadataRef LLVMDIBuilderCreateFunction(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *LinkageName, size_t LinkageNameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool IsLocalToUnit, LLVMBool IsDefinition, unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized)
Create a new descriptor for the specified subprogram.
LLVMDbgRecordRef LLVMDIBuilderInsertDeclareRecordAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Soon to be deprecated.
LLVMDbgRecordRef LLVMDIBuilderInsertDbgValueBefore(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Insert a new Value DbgRecord before the given instruction.
LLVMDbgRecordRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Insert a new Value DbgRecord at the end of the given basic block.
LLVMMetadataRef LLVMDIBuilderCreateBitFieldMemberType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint64_t OffsetInBits, uint64_t StorageOffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef Type)
Create debugging information entry for a bit field member.
LLVMMetadataRef LLVMDIGlobalVariableExpressionGetVariable(LLVMMetadataRef GVE)
Retrieves the DIVariable associated with this global variable expression.
LLVMMetadataRef LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder, LLVMMetadataRef Type)
Create a uniqued DIType* clone with FlagArtificial set.
void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder)
Construct any deferred debug info descriptors.
LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Discriminator)
Create a descriptor for a lexical block with a new file attached.
unsigned LLVMDISubprogramGetLine(LLVMMetadataRef Subprogram)
Get the line associated with a given subprogram.
LLVMMetadataRef LLVMDIBuilderCreateUnspecifiedType(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen)
Create a DWARF unspecified type.
LLVMMetadataRef LLVMDIBuilderCreateNameSpace(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope, const char *Name, size_t NameLen, LLVMBool ExportSymbols)
Creates a new descriptor for a namespace with the specified parent scope.
LLVMMetadataRef LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line, unsigned Column, LLVMMetadataRef Scope, LLVMMetadataRef InlinedAt)
Creates a new DebugLocation that describes a source location.
uint32_t LLVMDITypeGetAlignInBits(LLVMMetadataRef DType)
Get the alignment of this DIType in bits.
LLVMMetadataRef LLVMDIGlobalVariableExpressionGetExpression(LLVMMetadataRef GVE)
Retrieves the DIExpression associated with this global variable expression.
LLVMMetadataRef LLVMDIVariableGetScope(LLVMMetadataRef Var)
Get the metadata of the scope associated with a given variable.
LLVMMetadataRef LLVMInstructionGetDebugLoc(LLVMValueRef Inst)
Get the debug location for the given instruction.
LLVMMetadataRef LLVMDIBuilderCreateReferenceType(LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Type)
Create debugging information entry for a c++ style reference or rvalue reference type.
LLVMMetadataRef LLVMDIBuilderCreateModule(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentScope, const char *Name, size_t NameLen, const char *ConfigMacros, size_t ConfigMacrosLen, const char *IncludePath, size_t IncludePathLen, const char *APINotesFile, size_t APINotesFileLen)
Creates a new descriptor for a module with the specified parent scope.
LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M)
Construct a builder for a module, and do not allow for unresolved nodes attached to the module.
void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP)
Set the subprogram attached to a function.
LLVMDWARFSourceLanguage
Source languages known by DWARF.
LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder, int64_t LowerBound, int64_t Count)
Create a descriptor for a value range.
LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M)
Construct a builder for a module and collect unresolved nodes attached to the module in order to reso...
void LLVMDisposeTemporaryMDNode(LLVMMetadataRef TempNode)
Deallocate a temporary node.
LLVMMetadataRef LLVMDILocationGetScope(LLVMMetadataRef Location)
Get the local scope associated with this debug location.
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef NS, LLVMMetadataRef File, unsigned Line)
Create a descriptor for an imported namespace.
LLVMMetadataRef LLVMDIBuilderCreateTempMacroFile(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentMacroFile, unsigned Line, LLVMMetadataRef File)
Create debugging information temporary entry for a macro file.
void LLVMInstructionSetDebugLoc(LLVMValueRef Inst, LLVMMetadataRef Loc)
Set the debug location for the given instruction.
LLVMMetadataRef LLVMDIBuilderCreateEnumerator(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen, int64_t Value, LLVMBool IsUnsigned)
Create debugging information entry for an enumerator.
LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder, uint64_t *Addr, size_t Length)
Create a new descriptor for the specified variable which has a complex address expression for its add...
LLVMMetadataRef LLVMDIBuilderCreateVectorType(LLVMDIBuilderRef Builder, uint64_t Size, uint32_t AlignInBits, LLVMMetadataRef Ty, LLVMMetadataRef *Subscripts, unsigned NumSubscripts)
Create debugging information entry for a vector type.
LLVMMetadataRef LLVMDIBuilderCreateMemberPointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeType, LLVMMetadataRef ClassType, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags)
Create debugging information entry for a pointer to member.
LLVMValueRef LLVMDIBuilderInsertDeclareIntrinsicBefore(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Soon to be deprecated.
unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location)
Get the column number of this debug location.
LLVMDIFlags
Debug info flags.
LLVMValueRef LLVMDIBuilderInsertDbgValueIntrinsicAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Soon to be deprecated.
LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits)
Create a new descriptor for a local auto variable.
LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data, size_t NumElements)
Create a new temporary MDNode.
LLVMDIFlags LLVMDITypeGetFlags(LLVMMetadataRef DType)
Get the flags associated with this DIType.
const char * LLVMDIFileGetDirectory(LLVMMetadataRef File, unsigned *Len)
Get the directory of a given file.
void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TempTargetMetadata, LLVMMetadataRef Replacement)
Replace all uses of temporary metadata.
const char * LLVMDIFileGetFilename(LLVMMetadataRef File, unsigned *Len)
Get the name of a given file.
unsigned LLVMDebugMetadataVersion(void)
The current debug metadata version number.
unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef Module)
The version of debug metadata that's present in the provided Module.
unsigned LLVMDITypeGetLine(LLVMMetadataRef DType)
Get the source line where this DIType is declared.
LLVMMetadataRef LLVMDIVariableGetFile(LLVMMetadataRef Var)
Get the metadata of the file associated with a given variable.
LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef ImportedEntity, LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements, unsigned NumElements)
Create a descriptor for an imported module that aliases another imported entity descriptor.
LLVMMetadataRef LLVMDIBuilderCreateStaticMemberType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, LLVMMetadataRef Type, LLVMDIFlags Flags, LLVMValueRef ConstantVal, uint32_t AlignInBits)
Create debugging information entry for a C++ static data member.
uint16_t LLVMGetDINodeTag(LLVMMetadataRef MD)
Get the dwarf::Tag of a DINode.
LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits)
Create a new descriptor for the specified variable.
LLVMMetadataRef LLVMDIBuilderCreateTempGlobalVariableFwdDecl(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, const char *Linkage, size_t LnkLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit, LLVMMetadataRef Decl, uint32_t AlignInBits)
Create a new descriptor for the specified global variable that is temporary and meant to be RAUWed.
LLVMMetadataRef LLVMDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Type)
Create debugging information entry for a qualified type, e.g.
LLVMMetadataKind LLVMGetMetadataKind(LLVMMetadataRef Metadata)
Obtain the enumerated type of a Metadata instance.
LLVMMetadataRef LLVMDIBuilderCreateUnionType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags, LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang, const char *UniqueId, size_t UniqueIdLen)
Create debugging information entry for a union.
LLVMMetadataRef LLVMDIBuilderCreateForwardDecl(LLVMDIBuilderRef Builder, unsigned Tag, const char *Name, size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits, const char *UniqueIdentifier, size_t UniqueIdentifierLen)
Create a permanent forward-declared type.
LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags)
Create a new descriptor for a function parameter variable.
LLVMMetadataRef LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder, LLVMMetadataRef File, LLVMMetadataRef *ParameterTypes, unsigned NumParameterTypes, LLVMDIFlags Flags)
Create subroutine type.
LLVMMetadataRef LLVMDIBuilderCreateObjCProperty(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, const char *GetterName, size_t GetterNameLen, const char *SetterName, size_t SetterNameLen, unsigned PropertyAttributes, LLVMMetadataRef Ty)
Create debugging information entry for Objective-C property.
LLVMMetadataRef LLVMDIBuilderCreateMacro(LLVMDIBuilderRef Builder, LLVMMetadataRef ParentMacroFile, unsigned Line, LLVMDWARFMacinfoRecordType RecordType, const char *Name, size_t NameLen, const char *Value, size_t ValueLen)
Create debugging information entry for a macro.
LLVMDWARFEmissionKind
The amount of debug information to emit.
LLVMValueRef LLVMDIBuilderInsertDeclareIntrinsicAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Soon to be deprecated.
LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, uint64_t Size, uint32_t AlignInBits, LLVMMetadataRef Ty, LLVMMetadataRef *Subscripts, unsigned NumSubscripts)
Create debugging information entry for an array.
LLVMDbgRecordRef LLVMDIBuilderInsertDbgValueRecordAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Soon to be deprecated.
LLVMMetadataRef LLVMDIScopeGetFile(LLVMMetadataRef Scope)
Get the metadata of the file associated with a given scope.
void LLVMDIBuilderFinalizeSubprogram(LLVMDIBuilderRef Builder, LLVMMetadataRef Subprogram)
Finalize a specific subprogram.
LLVMMetadataRef LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder, uint64_t Value)
Create a new descriptor for the specified variable that does not have an address, but does have a con...
LLVMMetadataRef LLVMDIBuilderCreateClassType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements, unsigned NumElements, LLVMMetadataRef VTableHolder, LLVMMetadataRef TemplateParamsNode, const char *UniqueIdentifier, size_t UniqueIdentifierLen)
Create debugging information entry for a class.
LLVMMetadataRef LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags, LLVMMetadataRef Ty)
Create debugging information entry for a member.
unsigned LLVMDILocationGetLine(LLVMMetadataRef Location)
Get the line number of this debug location.
LLVMMetadataRef LLVMDIBuilderCreateNullPtrType(LLVMDIBuilderRef Builder)
Create C++11 nullptr type.
LLVMMetadataRef LLVMDIBuilderCreateInheritance(LLVMDIBuilderRef Builder, LLVMMetadataRef Ty, LLVMMetadataRef BaseTy, uint64_t BaseOffset, uint32_t VBPtrOffset, LLVMDIFlags Flags)
Create debugging information entry to establish inheritance relationship between two types.
LLVMDbgRecordRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Insert a new Declare DbgRecord at the end of the given basic block.
LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang, LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen, LLVMBool isOptimized, const char *Flags, size_t FlagsLen, unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen, LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining, LLVMBool DebugInfoForProfiling, const char *SysRoot, size_t SysRootLen, const char *SDK, size_t SDKLen)
A CompileUnit provides an anchor for all debugging information generated during this instance of comp...
LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef Module)
Strip debug info in the module if it exists.
LLVMDbgRecordRef LLVMDIBuilderInsertDeclareRecordBefore(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Soon to be deprecated.
LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name, size_t NameLen, uint64_t SizeInBits, LLVMDWARFTypeEncoding Encoding, LLVMDIFlags Flags)
Create debugging information entry for a basic type.
unsigned LLVMDIVariableGetLine(LLVMMetadataRef Var)
Get the source line where this DIVariable is declared.
LLVMDbgRecordRef LLVMDIBuilderInsertDbgValueRecordBefore(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Soon to be deprecated.
unsigned LLVMDWARFTypeEncoding
An LLVM DWARF type encoding.
LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line, unsigned Column)
Create a descriptor for a lexical block with the specified parent context.
LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Builder, LLVMMetadataRef *Data, size_t NumElements)
Create a type array.
LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(LLVMDIBuilderRef Builder, unsigned Tag, const char *Name, size_t NameLen, LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags, const char *UniqueIdentifier, size_t UniqueIdentifierLen)
Create a temporary forward-declared type.
LLVMValueRef LLVMDIBuilderInsertDbgValueIntrinsicBefore(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Soon to be deprecated.
const char * LLVMDIFileGetSource(LLVMMetadataRef File, unsigned *Len)
Get the source of a given file.
uint64_t LLVMDITypeGetOffsetInBits(LLVMMetadataRef DType)
Get the offset of this DIType in bits.
LLVMMetadataRef LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef Decl, LLVMMetadataRef File, unsigned Line, const char *Name, size_t NameLen, LLVMMetadataRef *Elements, unsigned NumElements)
Create a descriptor for an imported function, type, or variable.
LLVMMetadataRef LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename, size_t FilenameLen, const char *Directory, size_t DirectoryLen)
Create a file descriptor to hold debugging information for a file.
const char * LLVMDITypeGetName(LLVMMetadataRef DType, size_t *Length)
Get the name of this DIType.
unsigned LLVMMetadataKind
LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope, uint32_t AlignInBits)
Create debugging information entry for a typedef.
LLVMMetadataRef LLVMDIBuilderCreateStructType(LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags, LLVMMetadataRef DerivedFrom, LLVMMetadataRef *Elements, unsigned NumElements, unsigned RunTimeLang, LLVMMetadataRef VTableHolder, const char *UniqueId, size_t UniqueIdLen)
Create debugging information entry for a struct.
void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder)
Deallocates the DIBuilder and everything it owns.
LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy, uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace, const char *Name, size_t NameLen)
Create debugging information entry for a pointer.
LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func)
Get the metadata of the subprogram attached to a function.
@ LLVMGenericDINodeMetadataKind
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
struct LLVMOpaqueDbgRecord * LLVMDbgRecordRef
struct LLVMOpaqueContext * LLVMContextRef
The top-level container for all LLVM global data.
struct LLVMOpaqueBasicBlock * LLVMBasicBlockRef
Represents a basic block of instructions in LLVM IR.
struct LLVMOpaqueMetadata * LLVMMetadataRef
Represents an LLVM Metadata.
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
struct LLVMOpaqueDIBuilder * LLVMDIBuilderRef
Represents an LLVM debug info builder.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Assignment Tracking (at).
void deleteAll(Function *F)
Remove all Assignment Tracking related intrinsics and metadata from F.
AssignmentInstRange getAssignmentInsts(DIAssignID *ID)
Return a range of instructions (typically just one) that have ID as an attachment.
AssignmentMarkerRange getAssignmentMarkers(DIAssignID *ID)
Return a range of dbg.assign intrinsics which use \ID as an operand.
void trackAssignments(Function::iterator Start, Function::iterator End, const StorageToVarsMap &Vars, const DataLayout &DL, bool DebugPrints=false)
Track assignments to Vars between Start and End.
SmallVector< DbgVariableRecord * > getDVRAssignmentMarkers(const Instruction *Inst)
void deleteAssignmentMarkers(const Instruction *Inst)
Delete the llvm.dbg.assign intrinsics linked to Inst.
std::optional< AssignmentInfo > getAssignmentInfo(const DataLayout &DL, const MemIntrinsic *I)
bool calculateFragmentIntersect(const DataLayout &DL, const Value *Dest, uint64_t SliceOffsetInBits, uint64_t SliceSizeInBits, const DbgAssignIntrinsic *DbgAssign, std::optional< DIExpression::FragmentInfo > &Result)
Calculate the fragment of the variable in DAI covered from (Dest + SliceOffsetInBits) to to (Dest + S...
void RAUW(DIAssignID *Old, DIAssignID *New)
Replace all uses (and attachments) of Old with New.
Calculates the starting offsets for various sections within the .debug_names section.
void prune(LinkGraph &G)
Removes dead symbols/blocks/addressables.
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
TinyPtrVector< DbgDeclareInst * > findDbgDeclares(Value *V)
Finds dbg.declare intrinsics declaring local variables as living in the memory that 'V' points to.
bool stripDebugInfo(Function &F)
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V, SmallVectorImpl< DbgVariableRecord * > *DbgVariableRecords=nullptr)
Finds the debug info intrinsics describing a value.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
@ Import
Import information from summary.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
void findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V, SmallVectorImpl< DbgVariableRecord * > *DbgVariableRecords=nullptr)
Finds the llvm.dbg.value intrinsics describing a value.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
bool stripNonLineTableDebugInfo(Module &M)
Downgrade the debug info in a module to contain only line table information.
DebugLoc getDebugValueLoc(DbgVariableIntrinsic *DII)
Produce a DebugLoc to use for each dbg.declare that is promoted to a dbg.value.
unsigned getDebugMetadataVersionFromModule(const Module &M)
Return Debug Info Metadata Version by checking module flags.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
@ Ref
The access may reference the value stored in memory.
Attribute unwrap(LLVMAttributeRef Attr)
bool isAssignmentTrackingEnabled(const Module &M)
Return true if assignment tracking is enabled for module M.
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
LLVMAttributeRef wrap(Attribute Attr)
TinyPtrVector< DbgVariableRecord * > findDVRDeclares(Value *V)
As above, for DVRDeclares.
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
void updateLoopMetadataDebugLocations(Instruction &I, function_ref< Metadata *(Metadata *)> Updater)
Update the debug locations contained within the MD_loop metadata attached to the instruction I,...
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Holds the characteristics of one fragment of a larger variable.
static DIExpression::FragmentInfo intersect(DIExpression::FragmentInfo A, DIExpression::FragmentInfo B)
Returns a zero-sized fragment if A and B don't intersect.
Helper object to track which of three possible relocation mechanisms are used for a particular value ...
Describes properties of a store that has a static size and offset into a some base storage.
Helper struct for trackAssignments, below.