50 if (!V->isUsedByMetadata())
60 for (
User *U : MDV->users())
61 if (
auto *DDI = dyn_cast<DbgDeclareInst>(U))
69 if (!V->isUsedByMetadata())
76 for (
DPValue *DPV : L->getAllDPValueUsers())
77 if (DPV->getType() == DPValue::LocationType::Declare)
83template <
typename IntrinsicT,
89 if (!V->isUsedByMetadata())
102 auto AppendUsers = [&Ctx, &EncounteredIntrinsics, &EncounteredDPValues,
105 for (
User *U : MDV->users())
106 if (IntrinsicT *DVI = dyn_cast<IntrinsicT>(U))
107 if (EncounteredIntrinsics.
insert(DVI).second)
108 Result.push_back(DVI);
114 for (
DPValue *DPV : L->getAllDPValueUsers()) {
115 if (
Type == DPValue::LocationType::Any || DPV->getType() ==
Type)
116 if (EncounteredDPValues.
insert(DPV).second)
124 for (
Metadata *AL : L->getAllArgListUsers()) {
130 if (
Type == DPValue::LocationType::Any || DPV->getType() ==
Type)
131 if (EncounteredDPValues.
insert(DPV).second)
139 findDbgIntrinsics<DbgValueInst, DPValue::LocationType::Value>(DbgValues, V,
145 findDbgIntrinsics<DbgVariableIntrinsic, DPValue::LocationType::Any>(
146 DbgUsers, V, DPValues);
150 if (
auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
164 return DILocation::get(DII->
getContext(), 0, 0, Scope, InlinedAt);
176 return DILocation::get(DPV->
getContext(), 0, 0, Scope, InlinedAt);
193 for (
auto *
CU : M.debug_compile_units())
194 processCompileUnit(
CU);
195 for (
auto &
F : M.functions()) {
196 if (
auto *SP = cast_or_null<DISubprogram>(
F.getSubprogram()))
207 if (!addCompileUnit(
CU))
209 for (
auto *DIG :
CU->getGlobalVariables()) {
210 if (!addGlobalVariable(DIG))
212 auto *GV = DIG->getVariable();
213 processScope(GV->getScope());
214 processType(GV->getType());
216 for (
auto *ET :
CU->getEnumTypes())
218 for (
auto *RT :
CU->getRetainedTypes())
219 if (
auto *
T = dyn_cast<DIType>(RT))
223 for (
auto *
Import :
CU->getImportedEntities()) {
224 auto *Entity =
Import->getEntity();
225 if (
auto *
T = dyn_cast<DIType>(Entity))
227 else if (
auto *SP = dyn_cast<DISubprogram>(Entity))
229 else if (
auto *NS = dyn_cast<DINamespace>(Entity))
230 processScope(NS->getScope());
231 else if (
auto *M = dyn_cast<DIModule>(Entity))
232 processScope(M->getScope());
238 if (
auto *DVI = dyn_cast<DbgVariableIntrinsic>(&
I))
241 if (
auto DbgLoc =
I.getDebugLoc())
244 for (
const DbgRecord &DPR :
I.getDbgRecordRange())
251 processScope(Loc->getScope());
256 if (
const DPValue *DPV = dyn_cast<const DPValue>(&DR))
261void DebugInfoFinder::processType(
DIType *DT) {
265 if (
auto *ST = dyn_cast<DISubroutineType>(DT)) {
270 if (
auto *DCT = dyn_cast<DICompositeType>(DT)) {
271 processType(DCT->getBaseType());
273 if (
auto *
T = dyn_cast<DIType>(
D))
275 else if (
auto *SP = dyn_cast<DISubprogram>(
D))
280 if (
auto *DDT = dyn_cast<DIDerivedType>(DT)) {
281 processType(DDT->getBaseType());
285void DebugInfoFinder::processScope(
DIScope *Scope) {
288 if (
auto *Ty = dyn_cast<DIType>(Scope)) {
292 if (
auto *
CU = dyn_cast<DICompileUnit>(Scope)) {
296 if (
auto *SP = dyn_cast<DISubprogram>(Scope)) {
300 if (!addScope(Scope))
302 if (
auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
303 processScope(LB->getScope());
304 }
else if (
auto *NS = dyn_cast<DINamespace>(Scope)) {
305 processScope(NS->getScope());
306 }
else if (
auto *M = dyn_cast<DIModule>(Scope)) {
307 processScope(
M->getScope());
312 if (!addSubprogram(SP))
323 processCompileUnit(SP->getUnit());
324 processType(SP->getType());
325 for (
auto *Element : SP->getTemplateParams()) {
326 if (
auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
327 processType(TType->getType());
328 }
else if (
auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
329 processType(TVal->getType());
336 if (!NodesSeen.insert(DV).second)
342bool DebugInfoFinder::addType(
DIType *DT) {
346 if (!NodesSeen.insert(DT).second)
349 TYs.push_back(
const_cast<DIType *
>(DT));
356 if (!NodesSeen.insert(
CU).second)
364 if (!NodesSeen.insert(DIG).second)
375 if (!NodesSeen.insert(SP).second)
382bool DebugInfoFinder::addScope(
DIScope *Scope) {
387 if (
Scope->getNumOperands() == 0)
389 if (!NodesSeen.insert(Scope).second)
391 Scopes.push_back(Scope);
398 "Loop ID needs at least one operand");
400 "Loop ID should refer to itself");
409 else if (
Metadata *NewMD = Updater(MD))
421 MDNode *OrigLoopID =
I.getMetadata(LLVMContext::MD_loop);
425 I.setMetadata(LLVMContext::MD_loop, NewLoopID);
433 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
436 if (isa<DILocation>(
N) || Reachable.
count(
N))
440 for (
auto &OpIt :
N->operands()) {
448 return Reachable.
count(
N);
455 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
458 if (isa<DILocation>(
N) || AllDILocation.
count(
N))
460 if (!DIReachable.
count(
N))
464 for (
auto &OpIt :
N->operands()) {
479 if (isa<DILocation>(MD) || AllDILocation.
count(MD))
482 if (!DIReachable.
count(MD))
485 MDNode *
N = dyn_cast_or_null<MDNode>(MD);
490 bool HasSelfRef =
false;
491 for (
unsigned i = 0; i <
N->getNumOperands(); ++i) {
494 Args.push_back(
nullptr);
495 }
else if (
A == MD) {
496 assert(i == 0 &&
"expected i==0 for self-reference");
498 Args.push_back(
nullptr);
501 Args.push_back(NewArg);
504 if (Args.empty() || (HasSelfRef && Args.size() == 1))
515 assert(!
N->operands().empty() &&
"Missing self reference?");
526 [&Visited, &DILocationReachable](
const MDOperand &
Op) {
527 return isDILocationReachable(
528 Visited, DILocationReachable, Op.get());
536 [&Visited, &AllDILocation,
538 return isAllDILocation(Visited, AllDILocation,
539 DILocationReachable, Op.get());
550 bool Changed =
false;
551 if (
F.hasMetadata(LLVMContext::MD_dbg)) {
553 F.setSubprogram(
nullptr);
559 if (isa<DbgInfoIntrinsic>(&
I)) {
564 if (
I.getDebugLoc()) {
568 if (
auto *LoopID =
I.getMetadata(LLVMContext::MD_loop)) {
569 auto *NewLoopID = LoopIDsMap.
lookup(LoopID);
572 if (NewLoopID != LoopID)
573 I.setMetadata(LLVMContext::MD_loop, NewLoopID);
576 if (
I.hasMetadataOtherThanDebugLoc()) {
578 I.setMetadata(
"heapallocsite",
nullptr);
580 I.setMetadata(LLVMContext::MD_DIAssignID,
nullptr);
589 bool Changed =
false;
594 if (NMD.getName().starts_with(
"llvm.dbg.") ||
595 NMD.getName() ==
"llvm.gcov") {
596 NMD.eraseFromParent();
604 for (
auto &GV : M.globals()) {
605 Changed |= GV.eraseMetadata(LLVMContext::MD_dbg);
609 Materializer->setStripDebugInfo();
617class DebugTypeInfoRemoval {
622 MDNode *EmptySubroutineType;
646 auto Replacement = Replacements.find(M);
647 if (Replacement != Replacements.end())
648 return Replacement->second;
656 void traverseAndRemap(
MDNode *
N) { traverse(
N); }
661 auto *FileAndScope = cast_or_null<DIFile>(map(MDS->
getFile()));
664 auto *
Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
666 cast_or_null<DIType>(map(MDS->getContainingType()));
667 auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
668 auto Variables =
nullptr;
669 auto TemplateParams =
nullptr;
672 auto distinctMDSubprogram = [&]() {
673 return DISubprogram::getDistinct(
675 FileAndScope, MDS->getLine(),
Type, MDS->getScopeLine(),
676 ContainingType, MDS->getVirtualIndex(), MDS->getThisAdjustment(),
677 MDS->getFlags(), MDS->getSPFlags(), Unit, TemplateParams, Declaration,
682 return distinctMDSubprogram();
684 auto *NewMDS = DISubprogram::get(
686 FileAndScope, MDS->getLine(),
Type, MDS->getScopeLine(), ContainingType,
687 MDS->getVirtualIndex(), MDS->getThisAdjustment(), MDS->getFlags(),
688 MDS->getSPFlags(), Unit, TemplateParams, Declaration, Variables);
690 StringRef OldLinkageName = MDS->getLinkageName();
693 auto OrigLinkage = NewToLinkageName.find(NewMDS);
694 if (OrigLinkage != NewToLinkageName.end()) {
695 if (OrigLinkage->second == OldLinkageName)
701 return distinctMDSubprogram();
704 NewToLinkageName.insert({NewMDS, MDS->getLinkageName()});
714 auto *
File = cast_or_null<DIFile>(map(
CU->getFile()));
716 MDTuple *RetainedTypes =
nullptr;
717 MDTuple *GlobalVariables =
nullptr;
718 MDTuple *ImportedEntities =
nullptr;
719 return DICompileUnit::getDistinct(
720 CU->getContext(),
CU->getSourceLanguage(), File,
CU->getProducer(),
721 CU->isOptimized(),
CU->getFlags(),
CU->getRuntimeVersion(),
723 RetainedTypes, GlobalVariables, ImportedEntities,
CU->getMacros(),
724 CU->getDWOId(),
CU->getSplitDebugInlining(),
725 CU->getDebugInfoForProfiling(),
CU->getNameTableKind(),
726 CU->getRangesBaseAddress(),
CU->getSysRoot(),
CU->getSDK());
730 auto *
Scope = map(MLD->getScope());
731 auto *InlinedAt = map(MLD->getInlinedAt());
733 return DILocation::getDistinct(MLD->
getContext(), MLD->getLine(),
734 MLD->getColumn(), Scope, InlinedAt);
735 return DILocation::get(MLD->
getContext(), MLD->getLine(), MLD->getColumn(),
743 for (
auto &
I :
N->operands())
752 if (Replacements.count(
N))
758 if (
auto *MDSub = dyn_cast<DISubprogram>(
N)) {
759 remap(MDSub->getUnit());
760 return getReplacementSubprogram(MDSub);
762 if (isa<DISubroutineType>(
N))
763 return EmptySubroutineType;
764 if (
auto *
CU = dyn_cast<DICompileUnit>(
N))
765 return getReplacementCU(
CU);
768 if (
auto *MDLB = dyn_cast<DILexicalBlockBase>(
N))
770 return mapNode(MDLB->getScope());
771 if (
auto *MLD = dyn_cast<DILocation>(
N))
772 return getReplacementMDLocation(MLD);
779 return getReplacementMDNode(
N);
781 Replacements[
N] = doRemap(
N);
790void DebugTypeInfoRemoval::traverse(
MDNode *
N) {
791 if (!
N || Replacements.count(
N))
797 if (
auto *MDS = dyn_cast<DISubprogram>(Parent))
798 return Child == MDS->getRetainedNodes().
get();
807 while (!ToVisit.
empty()) {
808 auto *
N = ToVisit.
back();
809 if (!Opened.
insert(
N).second) {
815 for (
auto &
I :
N->operands())
816 if (
auto *MDN = dyn_cast_or_null<MDNode>(
I))
817 if (!Opened.
count(MDN) && !Replacements.count(MDN) && !
prune(
N, MDN) &&
818 !isa<DICompileUnit>(MDN))
824 bool Changed =
false;
828 if (
auto *DbgVal = M.getFunction(
Name)) {
829 while (!DbgVal->use_empty())
830 cast<Instruction>(DbgVal->user_back())->eraseFromParent();
831 DbgVal->eraseFromParent();
835 RemoveUses(
"llvm.dbg.declare");
836 RemoveUses(
"llvm.dbg.label");
837 RemoveUses(
"llvm.dbg.value");
840 for (
auto NMI = M.named_metadata_begin(), NME = M.named_metadata_end();
845 if (NMD->
getName() ==
"llvm.dbg.cu")
850 for (
auto &GV : M.globals())
851 GV.eraseMetadata(LLVMContext::MD_dbg);
853 DebugTypeInfoRemoval Mapper(M.getContext());
857 Mapper.traverseAndRemap(Node);
858 auto *NewNode = Mapper.mapNode(Node);
859 Changed |= Node != NewNode;
867 if (
auto *SP =
F.getSubprogram()) {
868 Mapper.traverseAndRemap(SP);
869 auto *NewSP = cast<DISubprogram>(Mapper.mapNode(SP));
870 Changed |= SP != NewSP;
871 F.setSubprogram(NewSP);
876 auto *Scope =
DL.getScope();
877 MDNode *InlinedAt =
DL.getInlinedAt();
878 Scope = remap(Scope);
879 InlinedAt = remap(InlinedAt);
885 I.setDebugLoc(remapDebugLoc(
I.getDebugLoc()));
889 if (
auto *Loc = dyn_cast_or_null<DILocation>(MD))
890 return remapDebugLoc(Loc).
get();
895 if (
I.hasMetadataOtherThanDebugLoc())
896 I.setMetadata(
"heapallocsite",
nullptr);
906 for (
auto &NMD : M.named_metadata()) {
923 if (
auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
924 M.getModuleFlag(
"Debug Info Version")))
925 return Val->getZExtValue();
941 if (
auto *MD =
I->getMetadata(LLVMContext::MD_DIAssignID))
944 "Merging with instruction from another function not allowed");
948 if (
auto *MD =
getMetadata(LLVMContext::MD_DIAssignID))
955 for (
auto It = std::next(IDs.
begin()),
End = IDs.
end(); It !=
End; ++It) {
971 bool MayLowerToCall =
false;
972 if (isa<CallBase>(
this)) {
973 auto *II = dyn_cast<IntrinsicInst>(
this);
978 if (!MayLowerToCall) {
1007#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
1008 case LLVMDWARFSourceLanguage##NAME: \
1010#include "llvm/BinaryFormat/Dwarf.def"
1011#undef HANDLE_DW_LANG
1017 return (DIT *)(
Ref ? unwrap<MDNode>(
Ref) :
nullptr);
1058 unwrap(Builder)->finalize();
1063 unwrap(Builder)->finalizeSubprogram(unwrapDI<DISubprogram>(subprogram));
1069 LLVMBool isOptimized,
const char *Flags,
size_t FlagsLen,
1070 unsigned RuntimeVer,
const char *SplitName,
size_t SplitNameLen,
1072 LLVMBool DebugInfoForProfiling,
const char *SysRoot,
size_t SysRootLen,
1073 const char *SDK,
size_t SDKLen) {
1074 auto File = unwrapDI<DIFile>(FileRef);
1076 return wrap(
unwrap(Builder)->createCompileUnit(
1079 RuntimeVer,
StringRef(SplitName, SplitNameLen),
1081 SplitDebugInlining, DebugInfoForProfiling,
1088 size_t FilenameLen,
const char *Directory,
1089 size_t DirectoryLen) {
1096 const char *
Name,
size_t NameLen,
1097 const char *ConfigMacros,
size_t ConfigMacrosLen,
1098 const char *IncludePath,
size_t IncludePathLen,
1099 const char *APINotesFile,
size_t APINotesFileLen) {
1102 StringRef(ConfigMacros, ConfigMacrosLen),
1104 StringRef(APINotesFile, APINotesFileLen)));
1109 const char *
Name,
size_t NameLen,
1111 return wrap(
unwrap(Builder)->createNameSpace(
1112 unwrapDI<DIScope>(ParentScope),
StringRef(
Name, NameLen), ExportSymbols));
1117 size_t NameLen,
const char *
LinkageName,
size_t LinkageNameLen,
1122 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {
LinkageName, LinkageNameLen},
1123 unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine,
1133 return wrap(
unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
1134 unwrapDI<DIFile>(File),
1142 unsigned Discriminator) {
1143 return wrap(
unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
1144 unwrapDI<DIFile>(File),
1155 unwrapDI<DINamespace>(NS),
1156 unwrapDI<DIFile>(File),
1166 ?
unwrap(Builder)->getOrCreateArray({
unwrap(Elements), NumElements})
1169 unwrapDI<DIScope>(Scope), unwrapDI<DIImportedEntity>(ImportedEntity),
1170 unwrapDI<DIFile>(File), Line, Elts));
1176 unsigned NumElements) {
1179 ?
unwrap(Builder)->getOrCreateArray({
unwrap(Elements), NumElements})
1182 unwrapDI<DIScope>(Scope), unwrapDI<DIModule>(M), unwrapDI<DIFile>(File),
1192 ?
unwrap(Builder)->getOrCreateArray({
unwrap(Elements), NumElements})
1194 return wrap(
unwrap(Builder)->createImportedDeclaration(
1195 unwrapDI<DIScope>(Scope), unwrapDI<DINode>(Decl), unwrapDI<DIFile>(File),
1196 Line, {
Name, NameLen}, Elts));
1208 return unwrapDI<DILocation>(Location)->getLine();
1212 return unwrapDI<DILocation>(Location)->getColumn();
1216 return wrap(unwrapDI<DILocation>(Location)->
getScope());
1220 return wrap(unwrapDI<DILocation>(Location)->getInlinedAt());
1224 return wrap(unwrapDI<DIScope>(Scope)->getFile());
1228 auto Dir = unwrapDI<DIFile>(File)->getDirectory();
1234 auto Name = unwrapDI<DIFile>(File)->getFilename();
1240 if (
auto Src = unwrapDI<DIFile>(File)->getSource()) {
1252 const char *
Name,
size_t NameLen,
1253 const char *
Value,
size_t ValueLen) {
1255 unwrap(Builder)->createMacro(unwrapDI<DIMacroFile>(ParentMacroFile), Line,
1264 return wrap(
unwrap(Builder)->createTempMacroFile(
1265 unwrapDI<DIMacroFile>(ParentMacroFile), Line, unwrapDI<DIFile>(File)));
1269 const char *
Name,
size_t NameLen,
1281auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1283return wrap(
unwrap(Builder)->createEnumerationType(
1284 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1285 LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
1292 LLVMMetadataRef *Elements,
unsigned NumElements,
unsigned RunTimeLang,
1293 const char *UniqueId,
size_t UniqueIdLen) {
1294 auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1296 return wrap(
unwrap(Builder)->createUnionType(
1297 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1299 Elts, RunTimeLang, {UniqueId, UniqueIdLen}));
1307 unsigned NumSubscripts) {
1308 auto Subs =
unwrap(Builder)->getOrCreateArray({
unwrap(Subscripts),
1311 unwrapDI<DIType>(Ty), Subs));
1318 unsigned NumSubscripts) {
1319 auto Subs =
unwrap(Builder)->getOrCreateArray({
unwrap(Subscripts),
1322 unwrapDI<DIType>(Ty), Subs));
1327 size_t NameLen,
uint64_t SizeInBits,
1331 SizeInBits, Encoding,
1338 const char *
Name,
size_t NameLen) {
1339 return wrap(
unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
1340 SizeInBits, AlignInBits,
1349 unsigned NumElements,
unsigned RunTimeLang,
LLVMMetadataRef VTableHolder,
1350 const char *UniqueId,
size_t UniqueIdLen) {
1351 auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1353 return wrap(
unwrap(Builder)->createStructType(
1354 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1356 unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
1357 unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
1365 return wrap(
unwrap(Builder)->createMemberType(unwrapDI<DIScope>(Scope),
1366 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits,
1373 return wrap(
unwrap(Builder)->createUnspecifiedType({
Name, NameLen}));
1381 return wrap(
unwrap(Builder)->createStaticMemberType(
1382 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1384 unwrap<Constant>(ConstantVal), DW_TAG_member, AlignInBits));
1389 const char *
Name,
size_t NameLen,
1395 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1396 SizeInBits, AlignInBits, OffsetInBits,
1398 unwrapDI<MDNode>(PropertyNode)));
1403 const char *
Name,
size_t NameLen,
1405 const char *GetterName,
size_t GetterNameLen,
1406 const char *SetterName,
size_t SetterNameLen,
1407 unsigned PropertyAttributes,
1409 return wrap(
unwrap(Builder)->createObjCProperty(
1410 {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1411 {GetterName, GetterNameLen}, {SetterName, SetterNameLen},
1412 PropertyAttributes, unwrapDI<DIType>(Ty)));
1418 return wrap(
unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(
Type)));
1423 const char *
Name,
size_t NameLen,
1427 unwrapDI<DIType>(
Type), {
Name, NameLen}, unwrapDI<DIFile>(File), LineNo,
1428 unwrapDI<DIScope>(Scope), AlignInBits));
1436 return wrap(
unwrap(Builder)->createInheritance(
1437 unwrapDI<DIType>(Ty), unwrapDI<DIType>(
BaseTy),
1446 const char *UniqueIdentifier,
size_t UniqueIdentifierLen) {
1447 return wrap(
unwrap(Builder)->createForwardDecl(
1448 Tag, {
Name, NameLen}, unwrapDI<DIScope>(Scope),
1449 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1450 AlignInBits, {UniqueIdentifier, UniqueIdentifierLen}));
1459 size_t UniqueIdentifierLen) {
1460 return wrap(
unwrap(Builder)->createReplaceableCompositeType(
1461 Tag, {
Name, NameLen}, unwrapDI<DIScope>(Scope),
1462 unwrapDI<DIFile>(File), Line, RuntimeLang, SizeInBits,
1464 {UniqueIdentifier, UniqueIdentifierLen}));
1471 unwrapDI<DIType>(
Type)));
1478 unwrapDI<DIType>(
Type)));
1483 return wrap(
unwrap(Builder)->createNullPtrType());
1493 return wrap(
unwrap(Builder)->createMemberPointerType(
1494 unwrapDI<DIType>(PointeeType),
1495 unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1502 const char *
Name,
size_t NameLen,
1508 return wrap(
unwrap(Builder)->createBitFieldMemberType(
1509 unwrapDI<DIScope>(Scope), {
Name, NameLen},
1510 unwrapDI<DIFile>(File), LineNumber,
1511 SizeInBits, OffsetInBits, StorageOffsetInBits,
1522 const char *UniqueIdentifier,
size_t UniqueIdentifierLen) {
1523 auto Elts =
unwrap(Builder)->getOrCreateArray({
unwrap(Elements),
1525 return wrap(
unwrap(Builder)->createClassType(
1526 unwrapDI<DIScope>(Scope), {
Name, NameLen}, unwrapDI<DIFile>(File),
1527 LineNumber, SizeInBits, AlignInBits, OffsetInBits,
1529 0, unwrapDI<DIType>(VTableHolder),
1530 unwrapDI<MDNode>(TemplateParamsNode),
1531 {UniqueIdentifier, UniqueIdentifierLen}));
1537 return wrap(
unwrap(Builder)->createArtificialType(unwrapDI<DIType>(
Type)));
1541 return unwrapDI<DINode>(MD)->getTag();
1545 StringRef Str = unwrapDI<DIType>(DType)->getName();
1551 return unwrapDI<DIType>(DType)->getSizeInBits();
1555 return unwrapDI<DIType>(DType)->getOffsetInBits();
1559 return unwrapDI<DIType>(DType)->getAlignInBits();
1563 return unwrapDI<DIType>(DType)->getLine();
1581 unsigned NumParameterTypes,
1583 auto Elts =
unwrap(Builder)->getOrCreateTypeArray({
unwrap(ParameterTypes),
1584 NumParameterTypes});
1585 return wrap(
unwrap(Builder)->createSubroutineType(
1603 size_t NameLen,
const char *Linkage,
size_t LinkLen,
LLVMMetadataRef File,
1606 return wrap(
unwrap(Builder)->createGlobalVariableExpression(
1607 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {Linkage, LinkLen},
1608 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1609 true, unwrap<DIExpression>(Expr), unwrapDI<MDNode>(Decl),
1610 nullptr, AlignInBits));
1614 return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getVariable());
1619 return wrap(unwrapDI<DIGlobalVariableExpression>(GVE)->getExpression());
1623 return wrap(unwrapDI<DIVariable>(Var)->getFile());
1631 return unwrapDI<DIVariable>(Var)->getLine();
1646 auto *
Node = unwrapDI<MDNode>(TargetMetadata);
1647 Node->replaceAllUsesWith(
unwrap(Replacement));
1653 size_t NameLen,
const char *Linkage,
size_t LnkLen,
LLVMMetadataRef File,
1656 return wrap(
unwrap(Builder)->createTempGlobalVariableFwdDecl(
1657 unwrapDI<DIScope>(Scope), {
Name, NameLen}, {Linkage, LnkLen},
1658 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1659 unwrapDI<MDNode>(Decl),
nullptr, AlignInBits));
1667 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1668 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
1669 unwrap<Instruction>(Instr));
1670 assert(isa<Instruction *>(DbgInst) &&
1671 "Inserted a DbgRecord into function using old debug info mode");
1672 return wrap(cast<Instruction *>(DbgInst));
1680 unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
1681 unwrap<DIExpression>(Expr), unwrap<DILocation>(
DL),
unwrap(
Block));
1682 assert(isa<Instruction *>(DbgInst) &&
1683 "Inserted a DbgRecord into function using old debug info mode");
1684 return wrap(cast<Instruction *>(DbgInst));
1691 unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap<DIExpression>(Expr),
1692 unwrap<DILocation>(
DebugLoc), unwrap<Instruction>(Instr));
1693 assert(isa<Instruction *>(DbgInst) &&
1694 "Inserted a DbgRecord into function using old debug info mode");
1695 return wrap(cast<Instruction *>(DbgInst));
1702 unwrap(Val), unwrap<DILocalVariable>(VarInfo), unwrap<DIExpression>(Expr),
1704 assert(isa<Instruction *>(DbgInst) &&
1705 "Inserted a DbgRecord into function using old debug info mode");
1706 return wrap(cast<Instruction *>(DbgInst));
1713 return wrap(
unwrap(Builder)->createAutoVariable(
1714 unwrap<DIScope>(Scope), {
Name, NameLen}, unwrap<DIFile>(File),
1715 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1721 size_t NameLen,
unsigned ArgNo,
LLVMMetadataRef File,
unsigned LineNo,
1723 return wrap(
unwrap(Builder)->createParameterVariable(
1724 unwrap<DIScope>(Scope), {
Name, NameLen}, ArgNo, unwrap<DIFile>(File),
1725 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1730 int64_t
Lo, int64_t Count) {
1731 return wrap(
unwrap(Builder)->getOrCreateSubrange(
Lo, Count));
1746 unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
1750 return unwrapDI<DISubprogram>(Subprogram)->getLine();
1759 unwrap<Instruction>(Inst)->setDebugLoc(
DebugLoc(unwrap<MDNode>(Loc)));
1761 unwrap<Instruction>(Inst)->setDebugLoc(
DebugLoc());
1766#define HANDLE_METADATA_LEAF(CLASS) \
1767 case Metadata::CLASS##Kind: \
1768 return (LLVMMetadataKind)LLVM##CLASS##MetadataKind;
1769#include "llvm/IR/Metadata.def"
1776 assert(
ID &&
"Expected non-null ID");
1780 auto MapIt = Map.find(
ID);
1781 if (MapIt == Map.end())
1784 return make_range(MapIt->second.begin(), MapIt->second.end());
1788 assert(
ID &&
"Expected non-null ID");
1798 return make_range(IDAsValue->user_begin(), IDAsValue->user_end());
1804 if (Range.empty() && DPVAssigns.
empty())
1807 for (
auto *DAI : ToDelete)
1808 DAI->eraseFromParent();
1809 for (
auto *DPV : DPVAssigns)
1810 DPV->eraseFromParent();
1820 for (
auto *
I : InstVec)
1821 I->setMetadata(LLVMContext::MD_DIAssignID, New);
1832 if (DPV.isDbgAssign())
1834 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(&
I))
1837 I.setMetadata(LLVMContext::MD_DIAssignID,
nullptr);
1840 for (
auto *DAI : ToDelete)
1841 DAI->eraseFromParent();
1842 for (
auto *DPV : DPToDelete)
1843 DPV->eraseFromParent();
1857 return VariableSlice;
1868 return VariableSlice;
1870template <
typename T>
1873 uint64_t SliceSizeInBits,
const T *AssignRecord,
1874 std::optional<DIExpression::FragmentInfo> &Result) {
1967 if (AssignRecord->isKillAddress())
1977 int64_t PointerOffsetInBits;
1979 auto DestOffsetInBytes =
1980 AssignRecord->getAddress()->getPointerOffsetFrom(Dest,
DL);
1981 if (!DestOffsetInBytes)
1984 int64_t ExprOffsetInBytes;
1985 if (!AssignRecord->getAddressExpression()->extractIfOffset(
1989 int64_t PointerOffsetInBytes = *DestOffsetInBytes + ExprOffsetInBytes;
1990 PointerOffsetInBits = PointerOffsetInBytes * 8;
1995 int64_t NewOffsetInBits =
1996 SliceOffsetInBits + VarFrag.
OffsetInBits - PointerOffsetInBits;
1997 if (NewOffsetInBits < 0)
2004 if (TrimmedSliceOfVariable == VarFrag)
2005 Result = std::nullopt;
2007 Result = TrimmedSliceOfVariable;
2013 std::optional<DIExpression::FragmentInfo> &Result) {
2015 SliceSizeInBits, DbgAssign, Result);
2020 std::optional<DIExpression::FragmentInfo> &Result) {
2022 SliceSizeInBits, DPVAssign, Result);
2028static std::optional<AssignmentInfo>
2032 return std::nullopt;
2033 APInt GEPOffset(
DL.getIndexTypeSizeInBits(StoreDest->
getType()), 0);
2035 DL, GEPOffset,
true);
2038 return std::nullopt;
2043 return std::nullopt;
2044 if (
const auto *Alloca = dyn_cast<AllocaInst>(
Base))
2046 return std::nullopt;
2051 const Value *StoreDest =
I->getRawDest();
2053 auto *ConstLengthInBytes = dyn_cast<ConstantInt>(
I->getLength());
2054 if (!ConstLengthInBytes)
2056 return std::nullopt;
2057 uint64_t SizeInBits = 8 * ConstLengthInBytes->getZExtValue();
2063 TypeSize SizeInBits =
DL.getTypeSizeInBits(SI->getValueOperand()->getType());
2077 auto *
ID = StoreLikeInst.
getMetadata(LLVMContext::MD_DIAssignID);
2078 assert(
ID &&
"Store instruction must have DIAssignID metadata");
2084 uint64_t FragStartBit = StoreStartBit;
2087 bool StoreToWholeVariable =
Info.StoreToWholeAlloca;
2096 FragEndBit = std::min(FragEndBit, VarEndBit);
2099 if (FragStartBit >= FragEndBit)
2102 StoreToWholeVariable = FragStartBit <= VarStartBit && FragEndBit >= *
Size;
2107 if (!StoreToWholeVariable) {
2109 FragEndBit - FragStartBit);
2110 assert(R.has_value() &&
"failed to create fragment expression");
2117 &StoreLikeInst, Val, VarRec.
Var, Expr, Dest, AddrExpr, VarRec.
DL);
2119 LLVM_DEBUG(
if (Assign)
errs() <<
" > INSERT: " << *Assign <<
"\n");
2123 AddrExpr, VarRec.
DL);
2126 if (Assign.is<DbgRecord *>())
2127 errs() <<
" > INSERT: " << *Assign.get<DbgRecord *>() <<
"\n";
2129 errs() <<
" > INSERT: " << *Assign.get<Instruction *>() <<
"\n";
2134#define DEBUG_TYPE "assignment-tracking"
2143 auto &Ctx = Start->getContext();
2144 auto &
Module = *Start->getModule();
2152 for (
auto BBI = Start; BBI !=
End; ++BBI) {
2155 std::optional<AssignmentInfo>
Info;
2156 Value *ValueComponent =
nullptr;
2157 Value *DestComponent =
nullptr;
2158 if (
auto *AI = dyn_cast<AllocaInst>(&
I)) {
2163 ValueComponent = Undef;
2165 }
else if (
auto *SI = dyn_cast<StoreInst>(&
I)) {
2167 ValueComponent = SI->getValueOperand();
2168 DestComponent = SI->getPointerOperand();
2169 }
else if (
auto *
MI = dyn_cast<MemTransferInst>(&
I)) {
2172 ValueComponent = Undef;
2173 DestComponent =
MI->getOperand(0);
2174 }
else if (
auto *
MI = dyn_cast<MemSetInst>(&
I)) {
2178 auto *ConstValue = dyn_cast<ConstantInt>(
MI->getOperand(1));
2179 if (ConstValue && ConstValue->isZero())
2180 ValueComponent = ConstValue;
2182 ValueComponent = Undef;
2183 DestComponent =
MI->getOperand(0);
2189 assert(ValueComponent && DestComponent);
2193 if (!
Info.has_value()) {
2196 <<
" | SKIP: Untrackable store (e.g. through non-const gep)\n");
2202 auto LocalIt = Vars.
find(
Info->Base);
2203 if (LocalIt == Vars.
end()) {
2206 <<
" | SKIP: Base address not associated with local variable\n");
2211 cast_or_null<DIAssignID>(
I.getMetadata(LLVMContext::MD_DIAssignID));
2214 I.setMetadata(LLVMContext::MD_DIAssignID,
ID);
2217 for (
const VarRecord &R : LocalIt->second)
2223bool AssignmentTrackingPass::runOnFunction(
Function &
F) {
2225 if (
F.hasFnAttribute(Attribute::OptimizeNone))
2228 bool Changed =
false;
2229 auto *
DL = &
F.getParent()->getDataLayout();
2238 auto ProcessDeclare = [&](
auto *Declare,
auto &DeclareList) {
2242 if (Declare->getExpression()->getNumElements() != 0)
2244 if (!Declare->getAddress())
2247 dyn_cast<AllocaInst>(Declare->getAddress()->stripPointerCasts())) {
2249 if (!Alloca->isStaticAlloca())
2252 if (
auto Sz = Alloca->getAllocationSize(*
DL); Sz && Sz->isScalable())
2254 DeclareList[Alloca].
insert(Declare);
2258 for (
auto &BB :
F) {
2259 for (
auto &
I : BB) {
2261 if (DPV.isDbgDeclare())
2262 ProcessDeclare(&DPV, DPVDeclares);
2265 ProcessDeclare(DDI, DbgDeclares);
2281 auto DeleteSubsumedDeclare = [&](
const auto &
Markers,
auto &Declares) {
2283 for (
auto *Declare : Declares) {
2297 Declare->eraseFromParent();
2301 for (
auto &
P : DbgDeclares)
2303 for (
auto &
P : DPVDeclares)
2309 "debug-info-assignment-tracking";
2319 return Value && !cast<ConstantAsMetadata>(
Value)->getValue()->isZeroValue();
2328 if (!runOnFunction(
F))
2345 bool Changed =
false;
2347 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 void findDbgIntrinsics(SmallVectorImpl< IntrinsicT * > &Result, Value *V, SmallVectorImpl< DPValue * > *DPValues)
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 LLVMDIFlags map_to_llvmDIFlags(DINode::DIFlags Flags)
static bool getAssignmentTrackingModuleFlag(const Module &M)
static DIExpression::FragmentInfo getFragmentOrEntireVariable(const DPValue *DPV)
Get the FragmentInfo for the variable if it exists, otherwise return a FragmentInfo that covers the e...
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.
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< DPValue * > getAllDPValueUsers()
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.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
DIExpression * getExpression() const
static DPValue * createLinkedDPVAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *Variable, DIExpression *Expression, Value *Address, DIExpression *AddressExpression, const DILocation *DI)
std::optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
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
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 DPValue 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.
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.
SmallVector< DPValue * > getDPVAssignmentMarkers(const Instruction *Inst)
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 *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.
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)
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.
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
TinyPtrVector< DPValue * > findDPVDeclares(Value *V)
As above, for DPVDeclares.
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.
void findDbgUsers(SmallVectorImpl< DbgVariableIntrinsic * > &DbgInsts, Value *V, SmallVectorImpl< DPValue * > *DPValues=nullptr)
Finds the debug info intrinsics describing a value.
@ 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.
void findDbgValues(SmallVectorImpl< DbgValueInst * > &DbgValues, Value *V, SmallVectorImpl< DPValue * > *DPValues=nullptr)
Finds the llvm.dbg.value intrinsics describing a value.
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)
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DPValue 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.