49 if (!V->isUsedByMetadata())
59 for (
User *U : MDV->users()) {
60 if (
auto *DDI = dyn_cast<DbgDeclareInst>(U))
67template <
typename IntrinsicT>
71 if (!V->isUsedByMetadata())
83 auto AppendUsers = [&Ctx, &EncounteredIntrinsics, &Result](
Metadata *MD) {
85 for (
User *U : MDV->users())
86 if (IntrinsicT *DVI = dyn_cast<IntrinsicT>(U))
87 if (EncounteredIntrinsics.
insert(DVI).second)
88 Result.push_back(DVI);
94 for (
Metadata *AL : L->getAllArgListUsers())
100 findDbgIntrinsics<DbgValueInst>(DbgValues, V);
105 findDbgIntrinsics<DbgVariableIntrinsic>(DbgUsers, V);
109 if (
auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
123 return DILocation::get(DII->
getContext(), 0, 0, Scope, InlinedAt);
140 for (
auto *
CU : M.debug_compile_units())
141 processCompileUnit(
CU);
142 for (
auto &
F : M.functions()) {
143 if (
auto *SP = cast_or_null<DISubprogram>(
F.getSubprogram()))
154 if (!addCompileUnit(
CU))
156 for (
auto *DIG :
CU->getGlobalVariables()) {
157 if (!addGlobalVariable(DIG))
159 auto *GV = DIG->getVariable();
160 processScope(GV->getScope());
161 processType(GV->getType());
163 for (
auto *ET :
CU->getEnumTypes())
165 for (
auto *RT :
CU->getRetainedTypes())
166 if (
auto *
T = dyn_cast<DIType>(RT))
170 for (
auto *
Import :
CU->getImportedEntities()) {
171 auto *Entity =
Import->getEntity();
172 if (
auto *
T = dyn_cast<DIType>(Entity))
174 else if (
auto *SP = dyn_cast<DISubprogram>(Entity))
176 else if (
auto *NS = dyn_cast<DINamespace>(Entity))
177 processScope(NS->getScope());
178 else if (
auto *M = dyn_cast<DIModule>(Entity))
179 processScope(M->getScope());
185 if (
auto *DVI = dyn_cast<DbgVariableIntrinsic>(&
I))
188 if (
auto DbgLoc =
I.getDebugLoc())
195 processScope(Loc->getScope());
199void DebugInfoFinder::processType(
DIType *DT) {
203 if (
auto *ST = dyn_cast<DISubroutineType>(DT)) {
208 if (
auto *DCT = dyn_cast<DICompositeType>(DT)) {
209 processType(DCT->getBaseType());
211 if (
auto *
T = dyn_cast<DIType>(
D))
213 else if (
auto *SP = dyn_cast<DISubprogram>(
D))
218 if (
auto *DDT = dyn_cast<DIDerivedType>(DT)) {
219 processType(DDT->getBaseType());
223void DebugInfoFinder::processScope(
DIScope *Scope) {
226 if (
auto *Ty = dyn_cast<DIType>(Scope)) {
230 if (
auto *
CU = dyn_cast<DICompileUnit>(Scope)) {
234 if (
auto *SP = dyn_cast<DISubprogram>(Scope)) {
238 if (!addScope(Scope))
240 if (
auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
241 processScope(LB->getScope());
242 }
else if (
auto *NS = dyn_cast<DINamespace>(Scope)) {
243 processScope(NS->getScope());
244 }
else if (
auto *M = dyn_cast<DIModule>(Scope)) {
245 processScope(
M->getScope());
250 if (!addSubprogram(SP))
261 processCompileUnit(SP->getUnit());
262 processType(SP->getType());
263 for (
auto *Element : SP->getTemplateParams()) {
264 if (
auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
265 processType(TType->getType());
266 }
else if (
auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
267 processType(TVal->getType());
278 auto *DV = dyn_cast<DILocalVariable>(
N);
282 if (!NodesSeen.insert(DV).second)
284 processScope(DV->getScope());
285 processType(DV->getType());
288bool DebugInfoFinder::addType(
DIType *DT) {
292 if (!NodesSeen.insert(DT).second)
295 TYs.push_back(
const_cast<DIType *
>(DT));
302 if (!NodesSeen.insert(
CU).second)
310 if (!NodesSeen.insert(DIG).second)
321 if (!NodesSeen.insert(SP).second)
328bool DebugInfoFinder::addScope(
DIScope *Scope) {
333 if (
Scope->getNumOperands() == 0)
335 if (!NodesSeen.insert(Scope).second)
337 Scopes.push_back(Scope);
344 "Loop ID needs at least one operand");
346 "Loop ID should refer to itself");
355 else if (
Metadata *NewMD = Updater(MD))
367 MDNode *OrigLoopID =
I.getMetadata(LLVMContext::MD_loop);
371 I.setMetadata(LLVMContext::MD_loop, NewLoopID);
379 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
382 if (isa<DILocation>(
N) || Reachable.
count(
N))
386 for (
auto &OpIt :
N->operands()) {
394 return Reachable.
count(
N);
401 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
404 if (isa<DILocation>(
N) || AllDILocation.
count(
N))
406 if (!DIReachable.
count(
N))
410 for (
auto &OpIt :
N->operands()) {
425 if (isa<DILocation>(MD) || AllDILocation.
count(MD))
428 if (!DIReachable.
count(MD))
431 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
436 bool HasSelfRef =
false;
437 for (
unsigned i = 0; i <
N->getNumOperands(); ++i) {
440 Args.push_back(
nullptr);
441 }
else if (
A == MD) {
442 assert(i == 0 &&
"expected i==0 for self-reference");
444 Args.push_back(
nullptr);
447 Args.push_back(NewArg);
450 if (Args.empty() || (HasSelfRef && Args.size() == 1))
461 assert(!
N->operands().empty() &&
"Missing self reference?");
472 [&Visited, &DILocationReachable](
const MDOperand &Op) {
473 return isDILocationReachable(
474 Visited, DILocationReachable, Op.get());
482 [&Visited, &AllDILocation,
483 &DILocationReachable](
const MDOperand &Op) {
484 return isAllDILocation(Visited, AllDILocation,
485 DILocationReachable, Op.get());
496 bool Changed =
false;
497 if (
F.hasMetadata(LLVMContext::MD_dbg)) {
499 F.setSubprogram(
nullptr);
505 if (isa<DbgInfoIntrinsic>(&
I)) {
510 if (
I.getDebugLoc()) {
514 if (
auto *LoopID =
I.getMetadata(LLVMContext::MD_loop)) {
515 auto *NewLoopID = LoopIDsMap.
lookup(LoopID);
518 if (NewLoopID != LoopID)
519 I.setMetadata(LLVMContext::MD_loop, NewLoopID);
522 if (
I.hasMetadataOtherThanDebugLoc()) {
524 I.setMetadata(
"heapallocsite",
nullptr);
526 I.setMetadata(LLVMContext::MD_DIAssignID,
nullptr);
534 bool Changed =
false;
539 if (NMD.getName().startswith(
"llvm.dbg.") ||
540 NMD.getName() ==
"llvm.gcov") {
541 NMD.eraseFromParent();
549 for (
auto &GV : M.globals()) {
550 Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
554 Materializer->setStripDebugInfo();
562class DebugTypeInfoRemoval {
567 MDNode *EmptySubroutineType;
591 auto Replacement = Replacements.find(M);
592 if (Replacement != Replacements.end())
593 return Replacement->second;
601 void traverseAndRemap(
MDNode *
N) { traverse(
N); }
606 auto *FileAndScope = cast_or_null<DIFile>(map(MDS->
getFile()));
609 auto *
Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
611 cast_or_null<DIType>(map(MDS->getContainingType()));
612 auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
613 auto Variables =
nullptr;
614 auto TemplateParams =
nullptr;
617 auto distinctMDSubprogram = [&]() {
618 return DISubprogram::getDistinct(
620 FileAndScope, MDS->getLine(),
Type, MDS->getScopeLine(),
621 ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
622 MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
627 return distinctMDSubprogram();
629 auto *NewMDS = DISubprogram::get(
631 FileAndScope, MDS->getLine(),
Type, MDS->getScopeLine(), ContainingType,
632 MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
633 MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
635 StringRef OldLinkageName = MDS->getLinkageName();
638 auto OrigLinkage = NewToLinkageName.find(NewMDS);
639 if (OrigLinkage != NewToLinkageName.end()) {
640 if (OrigLinkage->second == OldLinkageName)
646 return distinctMDSubprogram();
649 NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
659 auto *
File = cast_or_null<DIFile>(map(
CU->getFile()));
661 MDTuple *RetainedTypes =
nullptr;
662 MDTuple *GlobalVariables =
nullptr;
663 MDTuple *ImportedEntities =
nullptr;
664 return DICompileUnit::getDistinct(
665 CU->getContext(),
CU->getSourceLanguage(), File,
CU->getProducer(),
666 CU->isOptimized(),
CU->getFlags(),
CU->getRuntimeVersion(),
668 RetainedTypes, GlobalVariables, ImportedEntities,
CU->getMacros(),
669 CU->getDWOId(),
CU->getSplitDebugInlining(),
670 CU->getDebugInfoForProfiling(),
CU->getNameTableKind(),
671 CU->getRangesBaseAddress(),
CU->getSysRoot(),
CU->getSDK());
675 auto *
Scope = map(MLD->getScope());
676 auto *InlinedAt = map(MLD->getInlinedAt());
678 return DILocation::getDistinct(MLD->
getContext(), MLD->getLine(),
679 MLD->getColumn(), Scope, InlinedAt);
680 return DILocation::get(MLD->
getContext(), MLD->getLine(), MLD->getColumn(),
688 for (
auto &
I :
N->operands())
697 if (Replacements.count(
N))
703 if (
auto *MDSub = dyn_cast<DISubprogram>(
N)) {
704 remap(MDSub->getUnit());
705 return getReplacementSubprogram(MDSub);
707 if (isa<DISubroutineType>(
N))
708 return EmptySubroutineType;
709 if (
auto *
CU = dyn_cast<DICompileUnit>(
N))
710 return getReplacementCU(
CU);
713 if (
auto *MDLB = dyn_cast<DILexicalBlockBase>(
N))
715 return mapNode(MDLB->getScope());
716 if (
auto *MLD = dyn_cast<DILocation>(
N))
717 return getReplacementMDLocation(MLD);
724 return getReplacementMDNode(
N);
726 Replacements[
N] = doRemap(
N);
735void DebugTypeInfoRemoval::traverse(
MDNode *
N) {
736 if (!
N || Replacements.count(
N))
742 if (
auto *MDS = dyn_cast<DISubprogram>(Parent))
743 return Child == MDS->getRetainedNodes().
get();
752 while (!ToVisit.
empty()) {
753 auto *
N = ToVisit.
back();
754 if (!Opened.
insert(
N).second) {
760 for (
auto &
I :
N->operands())
761 if (
auto *MDN = dyn_cast_or_null<MDNode>(
I))
762 if (!Opened.
count(MDN) && !Replacements.count(MDN) && !
prune(
N, MDN) &&
763 !isa<DICompileUnit>(MDN))
769 bool Changed =
false;
773 if (
auto *DbgVal = M.getFunction(
Name)) {
774 while (!DbgVal->use_empty())
775 cast<Instruction>(DbgVal->user_back())->eraseFromParent();
776 DbgVal->eraseFromParent();
780 RemoveUses(
"llvm.dbg.declare");
781 RemoveUses(
"llvm.dbg.label");
782 RemoveUses(
"llvm.dbg.value");
785 for (
auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
790 if (NMD->
getName() ==
"llvm.dbg.cu")
795 for (
auto &GV : M.globals())
796 GV.eraseMetadata(LLVMContext::MD_dbg);
798 DebugTypeInfoRemoval Mapper(M.getContext());
802 Mapper.traverseAndRemap(Node);
803 auto *NewNode = Mapper.mapNode(Node);
804 Changed |= Node != NewNode;
812 if (
auto *SP =
F.getSubprogram()) {
813 Mapper.traverseAndRemap(SP);
814 auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
815 Changed |= SP != NewSP;
816 F.setSubprogram(NewSP);
821 auto *Scope =
DL.getScope();
822 MDNode *InlinedAt =
DL.getInlinedAt();
823 Scope = remap(Scope);
824 InlinedAt = remap(InlinedAt);
830 I.setDebugLoc(remapDebugLoc(
I.getDebugLoc()));
834 if (
auto *Loc = dyn_cast_or_null<DILocation>(MD))
835 return remapDebugLoc(Loc).
get();
840 if (
I.hasMetadataOtherThanDebugLoc())
841 I.setMetadata(
"heapallocsite",
nullptr);
848 for (
auto &NMD : M.named_metadata()) {
850 for (
MDNode *Op : NMD.operands())
865 if (
auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
866 M.getModuleFlag(
"Debug Info Version")))
867 return Val->getZExtValue();
883 if (
auto *MD =
I->getMetadata(LLVMContext::MD_DIAssignID))
886 "Merging with instruction from another function not allowed");
890 if (
auto *MD =
getMetadata(LLVMContext::MD_DIAssignID))
897 for (
auto It = std::next(IDs.
begin()),
End = IDs.
end(); It !=
End; ++It) {
913 bool MayLowerToCall =
false;
914 if (isa<CallBase>(
this)) {
915 auto *II = dyn_cast<IntrinsicInst>(
this);
920 if (!MayLowerToCall) {
949#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
950 case LLVMDWARFSourceLanguage##NAME: \
952#include "llvm/BinaryFormat/Dwarf.def"
959 return (DIT *)(
Ref ? unwrap<MDNode>(
Ref) :
nullptr);
1005 unwrap(
Builder)->finalizeSubprogram(unwrapDI<DISubprogram>(subprogram));
1011 LLVMBool isOptimized,
const char *Flags,
size_t FlagsLen,
1012 unsigned RuntimeVer,
const char *SplitName,
size_t SplitNameLen,
1014 LLVMBool DebugInfoForProfiling,
const char *SysRoot,
size_t SysRootLen,
1015 const char *SDK,
size_t SDKLen) {
1016 auto File = unwrapDI<DIFile>(FileRef);
1021 RuntimeVer,
StringRef(SplitName, SplitNameLen),
1023 SplitDebugInlining, DebugInfoForProfiling,
1030 size_t FilenameLen,
const char *Directory,
1031 size_t DirectoryLen) {
1038 const char *
Name,
size_t NameLen,
1039 const char *ConfigMacros,
size_t ConfigMacrosLen,
1040 const char *IncludePath,
size_t IncludePathLen,
1041 const char *APINotesFile,
size_t APINotesFileLen) {
1044 StringRef(ConfigMacros, ConfigMacrosLen),
1046 StringRef(APINotesFile, APINotesFileLen)));
1051 const char *
Name,
size_t NameLen,
1054 unwrapDI<DIScope>(ParentScope),
StringRef(
Name, NameLen), ExportSymbols));
1059 size_t NameLen,
const char *
LinkageName,
size_t LinkageNameLen,
1064 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {
LinkageName, LinkageNameLen},
1065 unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
1076 unwrapDI<DIFile>(File),
1084 unsigned Discriminator) {
1086 unwrapDI<DIFile>(File),
1097 unwrapDI<DINamespace>(NS),
1098 unwrapDI<DIFile>(File),
1111 unwrapDI<DIScope>(Scope), unwrapDI<DIImportedEntity>(ImportedEntity),
1112 unwrapDI<DIFile>(File), Line, Elts));
1118 unsigned NumElements) {
1124 unwrapDI<DIScope>(Scope), unwrapDI<DIModule>(M), unwrapDI<DIFile>(File),
1137 unwrapDI<DIScope>(Scope), unwrapDI<DINode>(Decl), unwrapDI<DIFile>(File),
1138 Line, {
Name, NameLen}, Elts));
1150 return unwrapDI<DILocation>(Location)->getLine();
1154 return unwrapDI<DILocation>(Location)->getColumn();
1158 return wrap(unwrapDI<DILocation>(Location)->
getScope());
1162 return wrap(unwrapDI<DILocation>(Location)->getInlinedAt());
1166 return wrap(unwrapDI<DIScope>(Scope)->getFile());
1170 auto Dir = unwrapDI<DIFile>(File)->getDirectory();
1176 auto Name = unwrapDI<DIFile>(File)->getFilename();
1182 if (
auto Src = unwrapDI<DIFile>(File)->getSource()) {
1194 const char *
Name,
size_t NameLen,
1195 const char *
Value,
size_t ValueLen) {
1197 unwrap(
Builder)->createMacro(unwrapDI<DIMacroFile>(ParentMacroFile), Line,
1207 unwrapDI<DIMacroFile>(ParentMacroFile), Line, unwrapDI<DIFile>(File)));
1211 const char *
Name,
size_t NameLen,
1226 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1227 LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
1234 LLVMMetadataRef *Elements,
unsigned NumElements,
unsigned RunTimeLang,
1235 const char *UniqueId,
size_t UniqueIdLen) {
1239 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1241 Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
1249 unsigned NumSubscripts) {
1253 unwrapDI<DIType>(Ty), Subs));
1260 unsigned NumSubscripts) {
1264 unwrapDI<DIType>(Ty), Subs));
1269 size_t NameLen,
uint64_t SizeInBits,
1273 SizeInBits, Encoding,
1280 const char *
Name,
size_t NameLen) {
1282 SizeInBits, AlignInBits,
1291 unsigned NumElements,
unsigned RunTimeLang,
LLVMMetadataRef VTableHolder,
1292 const char *UniqueId,
size_t UniqueIdLen) {
1296 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1298 unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
1299 unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
1308 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
1325 unwrapDI<DIScope>(Scope), {
Name, NameLen},
1326 unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(
Type),
1333 const char *
Name,
size_t NameLen,
1339 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1340 SizeInBits, AlignInBits, OffsetInBits,
1342 unwrapDI<MDNode>(PropertyNode)));
1347 const char *
Name,
size_t NameLen,
1349 const char *GetterName,
size_t GetterNameLen,
1350 const char *SetterName,
size_t SetterNameLen,
1351 unsigned PropertyAttributes,
1354 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1355 {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1356 PropertyAttributes, unwrapDI<DIType>(Ty)));
1367 const char *
Name,
size_t NameLen,
1371 unwrapDI<DIType>(
Type), {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1372 unwrapDI<DIScope>(Scope), AlignInBits));
1381 unwrapDI<DIType>(Ty), unwrapDI<DIType>(
BaseTy),
1390 const char *UniqueIdentifier,
size_t UniqueIdentifierLen) {
1392 Tag, {
Name, NameLen}, unwrapDI<DIScope>(Scope),
1393 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1394 AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1403 size_t UniqueIdentifierLen) {
1405 Tag, {
Name, NameLen}, unwrapDI<DIScope>(Scope),
1406 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1408 {UniqueIdentifier, UniqueIdentifierLen}));
1415 unwrapDI<DIType>(
Type)));
1422 unwrapDI<DIType>(
Type)));
1438 unwrapDI<DIType>(PointeeType),
1439 unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1446 const char *
Name,
size_t NameLen,
1453 unwrapDI<DIScope>(Scope), {
Name, NameLen},
1454 unwrapDI<DIFile>(File), LineNumber,
1455 SizeInBits, OffsetInBits, StorageOffsetInBits,
1466 const char *UniqueIdentifier,
size_t UniqueIdentifierLen) {
1470 unwrapDI<DIScope>(Scope), {
Name, NameLen},
1471 unwrapDI<DIFile>(File), LineNumber,
1472 SizeInBits, AlignInBits, OffsetInBits,
1474 Elts, unwrapDI<DIType>(VTableHolder),
1475 unwrapDI<MDNode>(TemplateParamsNode),
1476 {UniqueIdentifier, UniqueIdentifierLen}));
1486 return unwrapDI<DINode>(MD)->getTag();
1490 StringRef Str = unwrap<DIType>(DType)->getName();
1496 return unwrapDI<DIType>(DType)->getSizeInBits();
1500 return unwrapDI<DIType>(DType)->getOffsetInBits();
1504 return unwrapDI<DIType>(DType)->getAlignInBits();
1508 return unwrapDI<DIType>(DType)->getLine();
1526 unsigned NumParameterTypes,
1529 NumParameterTypes});
1548 size_t NameLen,
const char *Linkage,
size_t LinkLen,
LLVMMetadataRef File,
1552 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {Linkage, LinkLen},
1553 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1554 true, unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1555 nullptr, AlignInBits));
1559 return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getVariable());
1564 return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getExpression());
1568 return wrap(unwrapDI<DIVariable>(Var)->getFile());
1576 return unwrapDI<DIVariable>(Var)->getLine();
1591 auto *
Node = unwrapDI<MDNode>(TargetMetadata);
1592 Node->replaceAllUsesWith(
unwrap(Replacement));
1598 size_t NameLen,
const char *Linkage,
size_t LnkLen,
LLVMMetadataRef File,
1602 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {Linkage, LnkLen},
1603 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1604 unwrapDI<MDNode>(Decl),
nullptr, AlignInBits));
1612 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1613 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
1614 unwrap<Instruction>(Instr)));
1621 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1622 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
1633 unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1634 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DebugLoc),
1635 unwrap<Instruction>(Instr)));
1645 unwrap(Val), unwrap<DILocalVariable>(VarInfo),
1646 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DebugLoc),
1655 unwrap<DIScope>(Scope), {
Name, NameLen}, unwrap<DIFile>(File),
1656 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1662 size_t NameLen,
unsigned ArgNo,
LLVMMetadataRef File,
unsigned LineNo,
1665 unwrap<DIScope>(Scope), {
Name, NameLen}, ArgNo, unwrap<DIFile>(File),
1666 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1671 int64_t
Lo, int64_t Count) {
1687 unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1691 return unwrapDI<DISubprogram>(Subprogram)->getLine();
1700 unwrap<Instruction>(Inst)->setDebugLoc(
DebugLoc(unwrap<MDNode>(Loc)));
1702 unwrap<Instruction>(Inst)->setDebugLoc(
DebugLoc());
1707#define HANDLE_METADATA_LEAF(CLASS) \
1708 case Metadata::CLASS##Kind: \
1709 return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
1710#include "llvm/IR/Metadata.def"
1717 assert(
ID &&
"Expected non-null ID");
1721 auto MapIt = Map.find(
ID);
1722 if (MapIt == Map.end())
1725 return make_range(MapIt->second.begin(), MapIt->second.end());
1729 assert(
ID &&
"Expected non-null ID");
1739 return make_range(IDAsValue->user_begin(), IDAsValue->user_end());
1747 for (
auto *DAI : ToDelete)
1748 DAI->eraseFromParent();
1753 if (
auto *OldIDAsValue =
1756 OldIDAsValue->replaceAllUsesWith(NewIDAsValue);
1765 for (
auto *
I : InstVec)
1766 I->setMetadata(LLVMContext::MD_DIAssignID, New);
1773 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(&
I))
1776 I.setMetadata(LLVMContext::MD_DIAssignID,
nullptr);
1779 for (
auto *DAI : ToDelete)
1780 DAI->eraseFromParent();
1786 std::optional<DIExpression::FragmentInfo> &Result) {
1886 int64_t PointerOffsetInBits;
1889 if (!DestOffsetInBytes)
1892 int64_t ExprOffsetInBytes;
1896 int64_t PointerOffsetInBytes = *DestOffsetInBytes + ExprOffsetInBytes;
1897 PointerOffsetInBits = PointerOffsetInBytes * 8;
1902 int64_t NewOffsetInBits =
1903 SliceOffsetInBits + VarFrag.
OffsetInBits - PointerOffsetInBits;
1904 if (NewOffsetInBits < 0)
1910 if (TrimmedSliceOfVariable == VarFrag)
1911 Result = std::nullopt;
1913 Result = TrimmedSliceOfVariable;
1920static std::optional<AssignmentInfo>
1924 return std::nullopt;
1925 APInt GEPOffset(
DL.getIndexTypeSizeInBits(StoreDest->
getType()), 0);
1927 DL, GEPOffset,
true);
1930 return std::nullopt;
1935 return std::nullopt;
1936 if (
const auto *Alloca = dyn_cast<AllocaInst>(
Base))
1938 return std::nullopt;
1943 const Value *StoreDest =
I->getRawDest();
1945 auto *ConstLengthInBytes = dyn_cast<ConstantInt>(
I->getLength());
1946 if (!ConstLengthInBytes)
1948 return std::nullopt;
1949 uint64_t SizeInBits = 8 * ConstLengthInBytes->getZExtValue();
1955 TypeSize SizeInBits =
DL.getTypeSizeInBits(
SI->getValueOperand()->getType());
1969 auto *
ID = StoreLikeInst.
getMetadata(LLVMContext::MD_DIAssignID);
1970 assert(
ID &&
"Store instruction must have DIAssignID metadata");
1976 uint64_t FragStartBit = StoreStartBit;
1979 bool StoreToWholeVariable =
Info.StoreToWholeAlloca;
1988 FragEndBit = std::min(FragEndBit, VarEndBit);
1991 if (FragStartBit >= FragEndBit)
1994 StoreToWholeVariable = FragStartBit <= VarStartBit && FragEndBit >= *
Size;
1999 if (!StoreToWholeVariable) {
2001 FragEndBit - FragStartBit);
2002 assert(R.has_value() &&
"failed to create fragment expression");
2008 AddrExpr, VarRec.
DL);
2012#define DEBUG_TYPE "assignment-tracking"
2021 auto &Ctx = Start->getContext();
2022 auto &
Module = *Start->getModule();
2030 for (
auto BBI = Start; BBI !=
End; ++BBI) {
2033 std::optional<AssignmentInfo>
Info;
2034 Value *ValueComponent =
nullptr;
2035 Value *DestComponent =
nullptr;
2036 if (
auto *AI = dyn_cast<AllocaInst>(&
I)) {
2041 ValueComponent = Undef;
2043 }
else if (
auto *
SI = dyn_cast<StoreInst>(&
I)) {
2045 ValueComponent =
SI->getValueOperand();
2046 DestComponent =
SI->getPointerOperand();
2047 }
else if (
auto *
MI = dyn_cast<MemTransferInst>(&
I)) {
2050 ValueComponent = Undef;
2051 DestComponent =
MI->getOperand(0);
2052 }
else if (
auto *
MI = dyn_cast<MemSetInst>(&
I)) {
2056 auto *ConstValue = dyn_cast<ConstantInt>(
MI->getOperand(1));
2057 if (ConstValue && ConstValue->isZero())
2058 ValueComponent = ConstValue;
2060 ValueComponent = Undef;
2061 DestComponent =
MI->getOperand(0);
2067 assert(ValueComponent && DestComponent);
2071 if (!
Info.has_value()) {
2074 <<
" | SKIP: Untrackable store (e.g. through non-const gep)\n");
2080 auto LocalIt = Vars.
find(
Info->Base);
2081 if (LocalIt == Vars.
end()) {
2084 <<
" | SKIP: Base address not associated with local variable\n");
2089 cast_or_null<DIAssignID>(
I.getMetadata(LLVMContext::MD_DIAssignID));
2092 I.setMetadata(LLVMContext::MD_DIAssignID,
ID);
2095 for (
const VarRecord &R : LocalIt->second) {
2099 LLVM_DEBUG(
if (Assign)
errs() <<
" > INSERT: " << *Assign <<
"\n");
2105bool AssignmentTrackingPass::runOnFunction(
Function &
F) {
2107 if (
F.hasFnAttribute(Attribute::OptimizeNone))
2110 bool Changed =
false;
2111 auto *
DL = &
F.getParent()->getDataLayout();
2119 for (
auto &BB :
F) {
2120 for (
auto &
I : BB) {
2134 if (!Alloca->isStaticAlloca())
2137 if (
auto Sz = Alloca->getAllocationSize(*
DL); Sz && Sz->isScalable())
2139 DbgDeclares[Alloca].
insert(DDI);
2157 for (
auto &
P : DbgDeclares) {
2182 "debug-info-assignment-tracking";
2192 return Value && !cast<ConstantAsMetadata>(
Value)->getValue()->isZeroValue();
2201 if (!runOnFunction(
F))
2218 bool Changed =
false;
2220 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 DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, DINodeArray Elements, SmallVectorImpl< TrackingMDNodeRef > &AllImportedModules)
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
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)
static CallInst * 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 const char * AssignmentTrackingModuleFlag
static DINode::DIFlags map_from_llvmDIFlags(LLVMDIFlags Flags)
static void findDbgIntrinsics(SmallVectorImpl< IntrinsicT * > &Result, Value *V)
static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang)
static LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags)
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)
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.
Represents analyses that only rely on functions' control flow.
This class represents a function call, abstracting a target machine's calling convention.
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
static DIAssignID * getDistinct(LLVMContext &Context)
DbgAssignIntrinsic * insertDbgAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *SrcVar, DIExpression *ValExpr, Value *Addr, DIExpression *AddrExpr, const DILocation *DL)
Insert a new llvm.dbg.assign intrinsic call.
unsigned getNumElements() const
bool extractIfOffset(int64_t &Offset) const
If this is a constant offset, extract it.
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.
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.
A parsed version of the target data layout string in and methods for querying it.
This represents the llvm.dbg.assign instruction.
bool isKillAddress() const
Check whether this kills the address component.
DIExpression * getAddressExpression() const
Value * getAddress() const
This represents the llvm.dbg.declare instruction.
Value * getAddress() const
This is the common base class for debug info intrinsics for variables.
DIExpression::FragmentInfo getFragmentOrEntireVariable() const
Get the FragmentInfo for the variable if it exists, otherwise return a FragmentInfo that covers the e...
DILocalVariable * getVariable() const
DIExpression * getExpression() const
void processVariable(const Module &M, const DbgVariableIntrinsic &DVI)
Process DbgVariableIntrinsic.
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 processSubprogram(DISubprogram *SP)
Process subprogram.
void processLocation(const Module &M, const DILocation *Loc)
Process debug info location.
void reset()
Clear all lists.
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 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 ...
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
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)
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 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.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVMContext & getContext() const
All values hold a context through their type.
std::optional< int64_t > getPointerOffsetFrom(const Value *Other, const DataLayout &DL) const
If this ptr is provably equal to Other plus a constant offset, return that offset in bytes.
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.
LLVMValueRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Insert a new llvm.dbg.value intrinsic call at the end of the given basic block.
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.
LLVMValueRef LLVMDIBuilderInsertDbgValueBefore(LLVMDIBuilderRef Builder, LLVMValueRef Val, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Insert a new llvm.dbg.value intrinsic call before the given instruction.
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.
LLVMValueRef LLVMDIBuilderInsertDeclareBefore(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMValueRef Instr)
Insert a new llvm.dbg.declare intrinsic call before the given instruction.
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.
unsigned LLVMDILocationGetColumn(LLVMMetadataRef Location)
Get the column number of this debug location.
LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef Storage, LLVMMetadataRef VarInfo, LLVMMetadataRef Expr, LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block)
Insert a new llvm.dbg.declare intrinsic call at the end of the given basic block.
LLVMDIFlags
Debug info flags.
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.
LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, uint64_t Size, uint32_t AlignInBits, LLVMMetadataRef Ty, LLVMMetadataRef *Subscripts, unsigned NumSubscripts)
Create debugging information entry for an array.
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.
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.
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.
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.
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 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.
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 *DAI, 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.
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.
TinyPtrVector< DbgDeclareInst * > FindDbgDeclareUses(Value *V)
Finds dbg.declare intrinsics declaring local variables as living in the memory that 'V' points to.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool stripDebugInfo(Function &F)
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...
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V)
Finds the debug info intrinsics describing a value.
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.
void findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V)
Finds the llvm.dbg.value intrinsics describing a 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)
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.