74#define DEBUG_TYPE "function-attrs"
76STATISTIC(NumMemoryAttr,
"Number of functions with improved memory attribute");
77STATISTIC(NumCapturesNone,
"Number of arguments marked captures(none)");
78STATISTIC(NumCapturesPartial,
"Number of arguments marked with captures "
79 "attribute other than captures(none)");
80STATISTIC(NumReturned,
"Number of arguments marked returned");
81STATISTIC(NumReadNoneArg,
"Number of arguments marked readnone");
82STATISTIC(NumReadOnlyArg,
"Number of arguments marked readonly");
83STATISTIC(NumWriteOnlyArg,
"Number of arguments marked writeonly");
84STATISTIC(NumNoAlias,
"Number of function returns marked noalias");
85STATISTIC(NumNonNullReturn,
"Number of function returns marked nonnull");
86STATISTIC(NumNoUndefReturn,
"Number of function returns marked noundef");
87STATISTIC(NumNoRecurse,
"Number of functions marked as norecurse");
88STATISTIC(NumNoUnwind,
"Number of functions marked as nounwind");
89STATISTIC(NumNoFree,
"Number of functions marked as nofree");
90STATISTIC(NumNoFreeArg,
"Number of arguments marked as nofree");
91STATISTIC(NumWillReturn,
"Number of functions marked as willreturn");
92STATISTIC(NumNoSync,
"Number of functions marked as nosync");
93STATISTIC(NumCold,
"Number of functions marked as cold");
96 "Number of functions marked as norecurse during thinlink");
98 "Number of functions marked as nounwind during thinlink");
102 cl::desc(
"Don't propagate function-attrs in thinLTO"));
108 ++NumCapturesPartial;
142 if (!Arg->getType()->isPtrOrPtrVectorTy())
163static std::pair<MemoryEffects, MemoryEffects>
165 const SCCNodeSet &SCCNodes) {
191 if (
F.getAttributes().hasAttrSomewhere(Attribute::InAlloca) ||
192 F.getAttributes().hasAttrSomewhere(Attribute::Preallocated))
205 if (
Call && !
Call->hasOperandBundles() &&
Call->getCalledFunction() &&
206 SCCNodes.count(
Call->getCalledFunction())) {
214 if ((ME & OrigME) == OrigME)
231 AddNonArgMemoryEffects(CallME);
253 AddNonArgMemoryEffects(InstME);
257 return {OrigME & ME, RecursiveArgME};
266template <
typename AARGetterT>
277 auto [FnME, FnRecursiveArgME] =
280 RecursiveArgME |= FnRecursiveArgME;
294 if (NewME != OldME) {
296 F->setMemoryEffects(NewME);
300 A.removeAttr(Attribute::Writable);
314 auto [It, Inserted] = CachedPrevailingSummary.
try_emplace(VI);
361 for (
const auto &GVS : VI.getSummaryList()) {
367 if (!FS || FS->fflags().HasUnknownCall)
370 const auto &
Linkage = GVS->linkage();
375 <<
"ThinLTO FunctionAttrs: Multiple Local Linkage, bailing on "
377 << VI.name() <<
" from " << FS->modulePath() <<
". Previous module "
378 <<
Local->modulePath() <<
"\n");
383 assert(IsPrevailing(VI.getGUID(), GVS.get()) || GVS->wasPromoted());
390 if (IsPrevailing(VI.getGUID(), GVS.get())) {
400 auto &CPS = CachedPrevailingSummary[VI];
404 }
else if (Prevailing) {
424 auto PropagateAttributes = [&](std::vector<ValueInfo> &SCCNodes) {
427 InferredFlags.
NoRecurse = (SCCNodes.size() == 1);
430 for (
auto &V : SCCNodes) {
441 for (
const auto &Callee : CallerSummary->
calls()) {
443 Callee.first, CachedPrevailingSummary, IsPrevailing);
461 for (
auto &V : SCCNodes) {
463 LLVM_DEBUG(
dbgs() <<
"ThinLTO FunctionAttrs: Propagated NoRecurse to "
464 << V.name() <<
"\n");
465 ++NumThinLinkNoRecurse;
469 LLVM_DEBUG(
dbgs() <<
"ThinLTO FunctionAttrs: Propagated NoUnwind to "
470 << V.name() <<
"\n");
471 ++NumThinLinkNoUnwind;
474 for (
const auto &S : V.getSummaryList()) {
490 std::vector<ValueInfo> Nodes(*
I);
491 PropagateAttributes(Nodes);
501struct ArgumentGraphNode {
512 using ArgumentMapTy = std::map<Argument *, ArgumentGraphNode>;
514 ArgumentMapTy ArgumentMap;
522 ArgumentGraphNode SyntheticRoot;
525 ArgumentGraph() { SyntheticRoot.Definition =
nullptr; }
529 iterator
begin() {
return SyntheticRoot.Uses.begin(); }
530 iterator
end() {
return SyntheticRoot.Uses.end(); }
531 ArgumentGraphNode *getEntryNode() {
return &SyntheticRoot; }
533 ArgumentGraphNode *operator[](Argument *
A) {
534 ArgumentGraphNode &
Node = ArgumentMap[
A];
536 SyntheticRoot.Uses.push_back(&Node);
545 ArgumentUsesTracker(
const SCCNodeSet &SCCNodes) : SCCNodes(SCCNodes) {}
549 Action captured(
const Use *U, UseCaptureInfo UseCI)
override {
550 if (updateCaptureInfo(U, UseCI.
UseCC)) {
559 return ContinueIgnoringReturn;
570 CI |= CaptureInfo(
CC);
575 if (!
F || !
F->hasExactDefinition() || !SCCNodes.count(
F)) {
576 CI |= CaptureInfo(
CC);
590 CI |= CaptureInfo(
CC);
594 if (UseIndex >=
F->arg_size()) {
595 assert(
F->isVarArg() &&
"More params than args in non-varargs call");
596 CI |= CaptureInfo(
CC);
602 Uses.push_back(&*std::next(
F->arg_begin(), UseIndex));
612 const SCCNodeSet &SCCNodes;
620 std::optional<int64_t> Offset;
627struct ArgumentAccessInfo {
628 enum class AccessType : uint8_t {
Write, WriteWithSideEffect,
Read,
Unknown };
629 AccessType ArgAccessType;
630 ConstantRangeList AccessRanges;
634struct UsesPerBlockInfo {
635 SmallDenseMap<Instruction *, ArgumentAccessInfo, 4> Insts;
636 bool HasWrites =
false;
637 bool HasUnknownAccess =
false;
641struct ArgumentUsesSummary {
642 bool HasAnyWrite =
false;
643 bool HasWriteOutsideEntryBB =
false;
644 SmallDenseMap<const BasicBlock *, UsesPerBlockInfo, 16> UsesPerBlock;
647ArgumentAccessInfo getArgumentAccessInfo(
const Instruction *
I,
648 const ArgumentUse &ArgUse,
650 auto GetTypeAccessRange =
652 std::optional<int64_t>
Offset) -> std::optional<ConstantRange> {
666 auto GetConstantIntRange =
668 std::optional<int64_t>
Offset) -> std::optional<ConstantRange> {
670 if (ConstantLength &&
Offset) {
671 int64_t
Len = ConstantLength->getSExtValue();
689 if (
SI->isSimple() && &
SI->getOperandUse(1) == ArgUse.U) {
694 if (
auto TypeAccessRange =
695 GetTypeAccessRange(
SI->getAccessType(), ArgUse.Offset))
696 AccessRanges.
insert(*TypeAccessRange);
697 return {ArgumentAccessInfo::AccessType::Write, std::move(AccessRanges)};
700 if (LI->isSimple()) {
701 assert(&LI->getOperandUse(0) == ArgUse.U);
705 if (
auto TypeAccessRange =
706 GetTypeAccessRange(LI->getAccessType(), ArgUse.Offset))
707 return {ArgumentAccessInfo::AccessType::Read, {*TypeAccessRange}};
710 if (!MemSet->isVolatile()) {
712 if (
auto AccessRange =
713 GetConstantIntRange(MemSet->getLength(), ArgUse.Offset))
714 AccessRanges.
insert(*AccessRange);
715 return {ArgumentAccessInfo::AccessType::Write, AccessRanges};
718 if (!MTI->isVolatile()) {
719 if (&MTI->getOperandUse(0) == ArgUse.U) {
721 if (
auto AccessRange =
722 GetConstantIntRange(MTI->getLength(), ArgUse.Offset))
723 AccessRanges.
insert(*AccessRange);
724 return {ArgumentAccessInfo::AccessType::Write, AccessRanges};
725 }
else if (&MTI->getOperandUse(1) == ArgUse.U) {
726 if (
auto AccessRange =
727 GetConstantIntRange(MTI->getLength(), ArgUse.Offset))
728 return {ArgumentAccessInfo::AccessType::Read, {*AccessRange}};
735 bool IsInitialize = CB->
paramHasAttr(ArgNo, Attribute::Initializes);
736 if (IsInitialize && ArgUse.Offset) {
740 ? ArgumentAccessInfo::AccessType::Write
741 : ArgumentAccessInfo::AccessType::WriteWithSideEffect;
747 CR.getUpper() + *ArgUse.Offset));
748 return {
Access, AccessRanges};
753 return {ArgumentAccessInfo::AccessType::Unknown, {}};
758 auto &
DL =
F.getDataLayout();
760 DL.getIndexSizeInBits(
A.getType()->getPointerAddressSpace());
761 ArgumentUsesSummary
Result;
765 for (
Use &U :
A.uses())
771 auto *BB =
I->getParent();
772 auto &BBInfo =
Result.UsesPerBlock[BB];
773 auto [It,
Inserted] = BBInfo.Insts.try_emplace(
I);
774 auto &IInfo = It->second;
779 IInfo = {ArgumentAccessInfo::AccessType::Unknown, {}};
780 BBInfo.HasUnknownAccess =
true;
784 IInfo = std::move(Info);
785 BBInfo.HasUnknownAccess |=
786 IInfo.ArgAccessType == ArgumentAccessInfo::AccessType::Unknown;
788 (IInfo.ArgAccessType == ArgumentAccessInfo::AccessType::Write ||
789 IInfo.ArgAccessType ==
790 ArgumentAccessInfo::AccessType::WriteWithSideEffect) &&
791 !IInfo.AccessRanges.empty();
792 BBInfo.HasWrites |= InfoHasWrites;
793 return InfoHasWrites;
798 while (!Worklist.
empty()) {
800 User *U = ArgUse.U->getUser();
804 std::optional<int64_t> NewOffset = std::nullopt;
808 NewOffset = *ArgUse.Offset +
Offset.getSExtValue();
810 for (
Use &U :
GEP->uses())
816 bool HasWrite = UpdateUseInfo(
I, getArgumentAccessInfo(
I, ArgUse,
DL));
818 Result.HasAnyWrite |= HasWrite;
820 if (HasWrite &&
I->getParent() != &EntryBB)
821 Result.HasWriteOutsideEntryBB =
true;
877 if (
A->hasInAllocaAttr() ||
A->hasPreallocatedAttr())
882 for (
Use &U :
A->uses()) {
887 while (!Worklist.
empty()) {
913 for (
Use &UU :
I->uses())
914 if (Visited.
insert(&UU).second)
935 SCCNodes.
count(
F->getArg(UseIndex)))
958 Props.
IsRead |=
I->mayReadFromMemory();
959 Props.
IsWrite |=
I->mayWriteToMemory();
974 if (!
F->hasExactDefinition())
977 if (
F->getReturnType()->isVoidTy())
981 if (
F->getAttributes().hasAttrSomewhere(Attribute::Returned))
984 auto FindRetArg = [&]() ->
Argument * {
992 if (!RetVal || RetVal->getType() !=
F->getReturnType())
997 else if (RetArg != RetVal)
1004 if (
Argument *RetArg = FindRetArg()) {
1005 RetArg->addAttr(Attribute::Returned);
1017 if (!Opts.enable_poison_arg_attr_prop)
1033 for (
auto &CSArg : CalledFunc->args()) {
1034 unsigned ArgNo = CSArg.getArgNo();
1039 if (CSArg.hasNonNullAttr(
false)) {
1043 if (!FArg->hasNonNullAttr()) {
1044 FArg->addAttr(Attribute::NonNull);
1052 if ((CSNoFPClass | ArgNoFPClass) != ArgNoFPClass) {
1054 FArg->getContext(), CSNoFPClass | ArgNoFPClass));
1069 assert(
A &&
"Argument must not be null.");
1072 if (!Props.
IsFree && !
A->hasAttribute(Attribute::NoFree) &&
1073 !
A->hasAttribute(Attribute::NoFreeObj)) {
1075 A->addAttr(Attribute::NoFree);
1084 Attr = Attribute::ReadOnly;
1086 Attr = Attribute::WriteOnly;
1088 Attr = Attribute::ReadNone;
1091 if (
A->hasAttribute(Attr))
1096 A->removeAttr(Attribute::WriteOnly);
1097 A->removeAttr(Attribute::ReadOnly);
1098 A->removeAttr(Attribute::ReadNone);
1100 if (Attr == Attribute::ReadNone || Attr == Attribute::ReadOnly)
1101 A->removeAttr(Attribute::Writable);
1103 if (Attr == Attribute::ReadOnly)
1105 else if (Attr == Attribute::WriteOnly)
1116 const ArgumentUsesSummary &ArgumentUses) {
1117 const auto &UsesPerBlock = ArgumentUses.UsesPerBlock;
1119 auto UPB = UsesPerBlock.find(*It);
1120 if (UPB != UsesPerBlock.end() && UPB->second.HasWrites) {
1132 auto ArgumentUses = collectArgumentUsesPerBlock(
A,
F);
1134 if (!ArgumentUses.HasAnyWrite)
1137 auto &UsesPerBlock = ArgumentUses.UsesPerBlock;
1146 auto UPB = UsesPerBlock.find(BB);
1153 if (UPB == UsesPerBlock.end() || !UPB->second.HasUnknownAccess) {
1154 bool HasAddedSuccessor =
false;
1156 if (
auto SuccI = Initialized.
find(Succ); SuccI != Initialized.
end()) {
1157 if (HasAddedSuccessor) {
1160 CRL = SuccI->second;
1161 HasAddedSuccessor =
true;
1170 if (UPB != UsesPerBlock.end()) {
1174 sort(Insts, [](std::pair<Instruction *, ArgumentAccessInfo> &
LHS,
1175 std::pair<Instruction *, ArgumentAccessInfo> &
RHS) {
1176 return LHS.first->comesBefore(
RHS.first);
1181 for (
auto &[
_, Info] :
reverse(Insts)) {
1182 if (Info.ArgAccessType == ArgumentAccessInfo::AccessType::Unknown ||
1183 Info.ArgAccessType ==
1184 ArgumentAccessInfo::AccessType::WriteWithSideEffect)
1186 if (!Info.AccessRanges.empty()) {
1187 if (Info.ArgAccessType == ArgumentAccessInfo::AccessType::Write ||
1188 Info.ArgAccessType ==
1189 ArgumentAccessInfo::AccessType::WriteWithSideEffect) {
1192 assert(Info.ArgAccessType == ArgumentAccessInfo::AccessType::Read);
1193 for (
const auto &ReadRange : Info.AccessRanges)
1205 bool OnlyScanEntryBlock = !ArgumentUses.HasWriteOutsideEntryBB;
1206 if (!OnlyScanEntryBlock)
1207 if (
auto EntryUPB = UsesPerBlock.find(&EntryBB);
1208 EntryUPB != UsesPerBlock.end())
1209 OnlyScanEntryBlock = EntryUPB->second.HasUnknownAccess;
1210 if (OnlyScanEntryBlock) {
1211 EntryCRL = VisitBlock(&EntryBB);
1212 if (EntryCRL.
empty())
1228 Initialized[BB] = CRL;
1231 auto EntryCRLI = Initialized.
find(&EntryBB);
1232 if (EntryCRLI == Initialized.
end())
1235 EntryCRL = EntryCRLI->second;
1239 "should have bailed already if EntryCRL is empty");
1241 if (
A.hasAttribute(Attribute::Initializes)) {
1243 A.getAttribute(Attribute::Initializes).getValueAsConstantRangeList();
1244 if (PreviousCRL == EntryCRL)
1246 EntryCRL = EntryCRL.
unionWith(PreviousCRL);
1258 bool SkipInitializes) {
1261 auto DetermineAccessAttrsForSingleton = [](
Argument *
A) {
1273 if (!
F->hasExactDefinition())
1281 if (
F->onlyReadsMemory() &&
F->doesNotThrow() &&
F->willReturn() &&
1282 F->getReturnType()->isVoidTy()) {
1284 if (
A.getType()->isPointerTy() && !
A.hasNoCaptureAttr()) {
1295 if (!
A.getType()->isPointerTy())
1297 bool HasNonLocalUses =
false;
1298 CaptureInfo OrigCI =
A.getAttributes().getCaptureInfo();
1300 ArgumentUsesTracker Tracker(SCCNodes);
1303 if (NewCI != OrigCI) {
1304 if (Tracker.Uses.empty()) {
1313 ArgumentGraphNode *
Node = AG[&
A];
1316 Node->Uses.push_back(AG[
Use]);
1318 HasNonLocalUses =
true;
1324 if (!HasNonLocalUses && !
A.onlyReadsMemory()) {
1329 if (DetermineAccessAttrsForSingleton(&
A))
1332 if (!SkipInitializes && !
A.onlyReadsMemory()) {
1347 const std::vector<ArgumentGraphNode *> &ArgumentSCC = *
I;
1348 if (ArgumentSCC.size() == 1) {
1349 if (!ArgumentSCC[0]->Definition)
1353 if (ArgumentSCC[0]->
Uses.size() == 1 &&
1354 ArgumentSCC[0]->Uses[0] == ArgumentSCC[0]) {
1355 Argument *
A = ArgumentSCC[0]->Definition;
1356 CaptureInfo OrigCI =
A->getAttributes().getCaptureInfo();
1358 if (NewCI != OrigCI) {
1365 if (DetermineAccessAttrsForSingleton(
A))
1374 for (ArgumentGraphNode *
I : ArgumentSCC) {
1375 ArgumentSCCNodes.
insert(
I->Definition);
1382 for (ArgumentGraphNode *
N : ArgumentSCC) {
1383 for (ArgumentGraphNode *
Use :
N->Uses) {
1385 if (ArgumentSCCNodes.
count(
A))
1395 for (ArgumentGraphNode *
N : ArgumentSCC) {
1397 CaptureInfo OrigCI =
A->getAttributes().getCaptureInfo();
1399 if (NewCI != OrigCI) {
1410 for (ArgumentGraphNode *
N : ArgumentSCC) {
1411 if (DetermineAccessAttrsForSingleton(
N->Definition))
1412 Changed.insert(
N->Definition->getParent());
1429 for (ArgumentGraphNode *
N : ArgumentSCC) {
1437 for (ArgumentGraphNode *
N : ArgumentSCC) {
1454 FlowsToReturn.
insert(Ret->getReturnValue());
1456 for (
unsigned i = 0; i != FlowsToReturn.
size(); ++i) {
1457 Value *RetVal = FlowsToReturn[i];
1470 switch (RVI->getOpcode()) {
1472 case Instruction::BitCast:
1473 case Instruction::GetElementPtr:
1474 case Instruction::AddrSpaceCast:
1475 FlowsToReturn.
insert(RVI->getOperand(0));
1477 case Instruction::Select: {
1479 FlowsToReturn.
insert(
SI->getTrueValue());
1480 FlowsToReturn.
insert(
SI->getFalseValue());
1483 case Instruction::PHI: {
1490 case Instruction::Alloca:
1492 case Instruction::Call:
1493 case Instruction::Invoke: {
1523 if (
F->returnDoesNotAlias())
1529 if (!
F->hasExactDefinition())
1534 if (!
F->getReturnType()->isPointerTy())
1542 if (
F->returnDoesNotAlias() ||
1543 !
F->getReturnType()->isPointerTy())
1546 F->setReturnDoesNotAlias();
1560 bool &Speculative) {
1561 assert(
F->getReturnType()->isPointerTy() &&
1562 "nonnull only meaningful on pointer types");
1563 Speculative =
false;
1568 FlowsToReturn.
insert(Ret->getReturnValue());
1570 auto &
DL =
F->getDataLayout();
1572 for (
unsigned i = 0; i != FlowsToReturn.
size(); ++i) {
1573 Value *RetVal = FlowsToReturn[i];
1586 case Instruction::BitCast:
1587 case Instruction::AddrSpaceCast:
1590 case Instruction::GetElementPtr:
1596 case Instruction::Select: {
1598 FlowsToReturn.
insert(
SI->getTrueValue());
1599 FlowsToReturn.
insert(
SI->getFalseValue());
1602 case Instruction::PHI: {
1608 case Instruction::Call:
1609 case Instruction::Invoke: {
1614 if (Callee && SCCNodes.count(Callee)) {
1634 bool SCCReturnsNonNull =
true;
1640 if (
F->getAttributes().hasRetAttr(Attribute::NonNull))
1646 if (!
F->hasExactDefinition())
1651 if (!
F->getReturnType()->isPointerTy())
1654 bool Speculative =
false;
1660 <<
" as nonnull\n");
1661 F->addRetAttr(Attribute::NonNull);
1669 SCCReturnsNonNull =
false;
1672 if (SCCReturnsNonNull) {
1674 if (
F->getAttributes().hasRetAttr(Attribute::NonNull) ||
1675 !
F->getReturnType()->isPointerTy())
1678 LLVM_DEBUG(
dbgs() <<
"SCC marking " <<
F->getName() <<
" as nonnull\n");
1679 F->addRetAttr(Attribute::NonNull);
1694 if (Attrs.hasRetAttr(Attribute::NoUndef))
1700 if (!
F->hasExactDefinition())
1706 if (
F->hasFnAttribute(Attribute::SanitizeMemory))
1709 if (
F->getReturnType()->isVoidTy())
1716 Value *RetVal = Ret->getReturnValue();
1723 if (Attrs.hasRetAttr(Attribute::NonNull) &&
1732 Attribute Attr = Attrs.getRetAttr(Attribute::Range);
1739 FPClassTest AttrFPClass = Attrs.getRetNoFPClass();
1740 if (AttrFPClass !=
fcNone) {
1748 F->addRetAttr(Attribute::NoUndef);
1763class AttributeInferer {
1766 struct InferenceDescriptor {
1772 std::function<bool(
const Function &)> SkipFunction;
1775 std::function<bool(Instruction &)> InstrBreaksAttribute;
1778 std::function<void(
Function &)> SetAttribute;
1781 Attribute::AttrKind AKind;
1785 bool RequiresExactDefinition;
1787 InferenceDescriptor(Attribute::AttrKind AK,
1788 std::function<
bool(
const Function &)> SkipFunc,
1789 std::function<
bool(Instruction &)> InstrScan,
1790 std::function<
void(
Function &)> SetAttr,
1792 : SkipFunction(SkipFunc), InstrBreaksAttribute(InstrScan),
1793 SetAttribute(SetAttr), AKind(AK),
1794 RequiresExactDefinition(ReqExactDef) {}
1801 void registerAttrInference(InferenceDescriptor AttrInference) {
1802 InferenceDescriptors.push_back(AttrInference);
1805 void run(
const SCCNodeSet &SCCNodes, SmallPtrSet<Function *, 8> &
Changed);
1810void AttributeInferer::run(
const SCCNodeSet &SCCNodes,
1819 if (InferInSCC.
empty())
1824 if (
ID.SkipFunction(*
F))
1829 return F->isDeclaration() ||
1830 (
ID.RequiresExactDefinition && !
F->hasExactDefinition());
1837 InferInSCC, std::back_inserter(InferInThisFunc),
1838 [
F](
const InferenceDescriptor &ID) {
return !
ID.SkipFunction(*
F); });
1840 if (InferInThisFunc.empty())
1845 llvm::erase_if(InferInThisFunc, [&](
const InferenceDescriptor &ID) {
1846 if (!
ID.InstrBreaksAttribute(
I))
1851 return D.AKind ==
ID.AKind;
1857 if (InferInThisFunc.empty())
1862 if (InferInSCC.
empty())
1870 for (
auto &ID : InferInSCC) {
1871 if (
ID.SkipFunction(*
F))
1874 ID.SetAttribute(*
F);
1878struct SCCNodesResult {
1879 SCCNodeSet SCCNodes;
1886 const SCCNodeSet &SCCNodes) {
1896 if (!
I.mayThrow(
true))
1899 if (
Function *Callee = CI->getCalledFunction()) {
1903 if (SCCNodes.contains(Callee))
1916 return I.maySynchronize();
1924 if (SCCNodes.contains(Callee))
1931 if (!
I.maySynchronize())
1938 if (SCCNodes.contains(Callee))
1949 AttributeInferer AI;
1956 AI.registerAttrInference(AttributeInferer::InferenceDescriptor{
1957 Attribute::Convergent,
1959 [](
const Function &
F) {
return !
F.isConvergent(); },
1965 LLVM_DEBUG(
dbgs() <<
"Removing convergent attr from fn " <<
F.getName()
1967 F.setNotConvergent();
1979 const SCCNodeSet &SCCNodes,
1981 AttributeInferer AI;
1983 if (Opts.nounwind_inference)
1989 AI.registerAttrInference(AttributeInferer::InferenceDescriptor{
1990 Attribute::NoUnwind,
1992 [](
const Function &
F) {
return F.doesNotThrow(); },
1999 <<
"Adding nounwind attr to fn " <<
F.getName() <<
"\n");
2000 F.setDoesNotThrow();
2005 if (Opts.nofree_inference)
2012 AI.registerAttrInference(AttributeInferer::InferenceDescriptor{
2015 [](
const Function &
F) {
return F.doesNotFreeMemory(); },
2022 <<
"Adding nofree attr to fn " <<
F.getName() <<
"\n");
2023 F.setDoesNotFreeMemory();
2028 AI.registerAttrInference(AttributeInferer::InferenceDescriptor{
2031 [](
const Function &
F) {
return F.hasNoSync(); },
2038 <<
"Adding nosync attr to fn " <<
F.getName() <<
"\n");
2056 bool AnyFunctionsAddressIsTaken =
true) {
2057 for (
const auto &BB :
F) {
2058 for (
const auto &
I : BB) {
2061 if (!Callee || Callee == &
F)
2064 if (Callee->doesNotRecurse())
2067 if (!AnyFunctionsAddressIsTaken ||
2068 (Callee->isDeclaration() &&
2069 Callee->hasFnAttribute(Attribute::NoCallback)))
2083 if (SCCNodes.size() != 1)
2087 if (!
F || !
F->hasExactDefinition() ||
F->doesNotRecurse())
2093 F->setDoesNotRecurse();
2103 if (!
F || !
F->hasExactDefinition() ||
F->hasFnAttribute(Attribute::Naked) ||
2108 F->setDoesNotReturn();
2116 ColdPaths[&
F.front()] =
false;
2120 while (!Jobs.
empty()) {
2131 ColdPaths[BB] =
true;
2148 auto [Iter, Inserted] = ColdPaths.
try_emplace(Succ,
false);
2164 if (!
F || !
F->hasExactDefinition() ||
F->hasFnAttribute(Attribute::Naked) ||
2165 F->hasFnAttribute(Attribute::Cold) ||
F->hasFnAttribute(Attribute::Hot))
2170 F->addFnAttr(Attribute::Cold);
2182 if (!
F.hasExactDefinition())
2186 if (
F.mustProgress() &&
F.onlyReadsMemory())
2190 if (
F.isDeclaration())
2197 if (!Backedges.
empty())
2203 return I.willReturn();
2223 if (!
F ||
F->hasOptNone() ||
F->hasFnAttribute(Attribute::Naked) ||
2224 F->isPresplitCoroutine()) {
2229 Res.SCCNodes.insert(
F);
2234template <
typename AARGetterT>
2235static SmallPtrSet<Function *, 8>
2237 bool ArgAttrsOnly) {
2241 if (Nodes.SCCNodes.empty())
2244 const IPOOptions &Opts =
getIPOOptions(*Nodes.SCCNodes.front());
2286 bool ArgAttrsOnly =
false;
2287 if (
C.size() == 1 && SkipNonRecursive) {
2290 ArgAttrsOnly =
true;
2304 Functions.push_back(&
N.getFunction());
2307 auto ChangedFunctions =
2309 if (ChangedFunctions.empty())
2323 for (
auto *U :
Changed->users()) {
2326 FAM.invalidate(*
Call->getFunction(), FuncPA);
2341 static_cast<PassInfoMixin<PostOrderFunctionAttrsPass> *
>(
this)->
printPipeline(
2342 OS, MapClassName2PassName);
2343 if (SkipNonRecursive)
2344 OS <<
"<skip-non-recursive-function-attrs>";
2348 if (
F.doesNotRecurse())
2354 assert(!
F.isDeclaration() &&
"Cannot deduce norecurse without a definition!");
2355 assert(
F.hasInternalLinkage() &&
2356 "Can only do top-down deduction for internal linkage functions!");
2366 for (
auto &U :
F.uses()) {
2369 !CB->
getParent()->getParent()->doesNotRecurse())
2372 F.setDoesNotRecurse();
2378 assert(!
F.isDeclaration() &&
"Cannot deduce nofpclass without a definition!");
2379 unsigned NumArgs =
F.arg_size();
2384 for (
User *U :
F.users()) {
2390 for (
unsigned I = 0;
I != NumArgs; ++
I) {
2395 ArgsNoFPClass[
I] &= ~Cst->classify();
2403 if (RetNoFPClass !=
fcNone) {
2404 FPClassTest OldAttr =
F.getAttributes().getRetNoFPClass();
2405 if (OldAttr != RetNoFPClass) {
2411 for (
unsigned I = 0;
I != NumArgs; ++
I) {
2413 if (ArgNoFPClass ==
fcNone)
2416 if (OldAttr == ArgNoFPClass)
2439 if (SCC.size() != 1)
2441 Function &
F = SCC.begin()->getFunction();
2442 if (!
F.isDeclaration() &&
F.hasInternalLinkage() && !
F.use_empty())
2475 bool AnyFunctionsAddressIsTaken =
false;
2477 if (
F.isDeclaration() ||
F.doesNotRecurse())
2479 if (!
F.hasLocalLinkage() ||
F.hasAddressTaken()) {
2480 AnyFunctionsAddressIsTaken =
true;
2505 if (!
F.hasExactDefinition() ||
F.doesNotRecurse())
2512 F.setDoesNotRecurse();
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Expand Atomic instructions
This file contains the simple types necessary to represent the attributes associated with functions a...
This is the interface for LLVM's primary stateless and local alias analysis.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This header provides classes for managing passes over SCCs of the call graph.
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
This file builds on the ADT/GraphTraits.h file to build generic depth first graph iterator.
static bool canExitWithoutWrites(const BasicBlock &EntryBB, const ArgumentUsesSummary &ArgumentUses)
Return true if a block without successors is reachable from EntryBB without passing through a block t...
static SmallPtrSet< Function *, 8 > deriveAttrsInPostOrder(ArrayRef< Function * > Functions, AARGetterT &&AARGetter, bool ArgAttrsOnly)
static void addArgumentAttrs(const IPOOptions &Opts, const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed, bool SkipInitializes)
Deduce nocapture attributes for the SCC.
static bool inferInitializes(Argument &A, Function &F)
static bool allPathsGoThroughCold(Function &F)
static FunctionSummary * calculatePrevailingSummary(ValueInfo VI, DenseMap< ValueInfo, FunctionSummary * > &CachedPrevailingSummary, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> IsPrevailing)
static void addMemoryAttrs(const SCCNodeSet &SCCNodes, AARGetterT &&AARGetter, SmallPtrSet< Function *, 8 > &Changed)
Deduce readonly/readnone/writeonly attributes for the SCC.
static void addCapturesStat(CaptureInfo CI)
static void addArgLocs(MemoryEffects &ME, const CallBase *Call, ModRefInfo ArgMR, AAResults &AAR)
static bool isFunctionMallocLike(Function *F, const SCCNodeSet &SCCNodes)
Tests whether a function is "malloc-like".
static void addColdAttrs(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
static bool addArgumentAttrsFromCallsites(const IPOOptions &Opts, Function &F)
If a callsite has arguments that are also arguments to the parent function, try to propagate attribut...
static bool mayHaveRecursiveCallee(Function &F, bool AnyFunctionsAddressIsTaken=true)
static void addNoReturnAttrs(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
static bool addNoFPClassAttrsTopDown(Function &F)
static void addWillReturn(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
static void inferAttrsFromFunctionBodies(const IPOOptions &Opts, const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
Infer attributes from all functions in the SCC by scanning every instruction for compliance to the at...
static void addNonNullAttrs(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
Deduce nonnull attributes for the SCC.
static std::pair< MemoryEffects, MemoryEffects > checkFunctionMemoryAccess(Function &F, bool ThisBody, AAResults &AAR, const SCCNodeSet &SCCNodes)
Returns the memory access attribute for function F using AAR for AA results, where SCCNodes is the cu...
static bool InstrBreaksNonThrowing(Instruction &I, const SCCNodeSet &SCCNodes)
Helper for NoUnwind inference predicate InstrBreaksAttribute.
static bool isReturnNonNull(Function *F, const SCCNodeSet &SCCNodes, bool &Speculative)
Tests whether this function is known to not return null.
static bool InstrBreaksNoSync(Instruction &I, const SCCNodeSet &SCCNodes)
static bool deduceFunctionAttributeInRPO(Module &M, LazyCallGraph &CG)
static ArgAccessProperties determinePointerAccessAttrs(Argument *A, const SmallPtrSet< Argument *, 8 > &SCCNodes)
Returns Attribute::None, Attribute::ReadOnly or Attribute::ReadNone.
static bool InstrBreaksNoFree(Instruction &I, const SCCNodeSet &SCCNodes)
Helper for NoFree inference predicate InstrBreaksAttribute.
static bool addAccessAttrs(Argument *A, ArgAccessProperties Props)
static void addNoAliasAttrs(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
Deduce noalias attributes for the SCC.
static bool addNoRecurseAttrsTopDown(Function &F)
static void addLocAccess(MemoryEffects &ME, const MemoryLocation &Loc, ModRefInfo MR, AAResults &AAR)
static void inferConvergent(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
Attempt to remove convergent function attribute when possible.
static cl::opt< bool > DisableThinLTOPropagation("disable-thinlto-funcattrs", cl::init(true), cl::Hidden, cl::desc("Don't propagate function-attrs in thinLTO"))
static SCCNodesResult createSCCNodeSet(ArrayRef< Function * > Functions)
static bool InstrBreaksNonConvergent(Instruction &I, const SCCNodeSet &SCCNodes)
Helper for non-Convergent inference predicate InstrBreaksAttribute.
static void addNoRecurseAttrs(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
static bool functionWillReturn(const Function &F)
static void addNoUndefAttrs(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
Deduce noundef attributes for the SCC.
static void addArgumentReturnedAttrs(const SCCNodeSet &SCCNodes, SmallPtrSet< Function *, 8 > &Changed)
Deduce returned attributes for the SCC.
Provides passes for computing function attributes based on interprocedural analyses.
This header defines various interfaces for pass management in LLVM.
This defines the Use class.
Implements a lazy call graph analysis and related passes for the new pass manager.
This file provides utility analysis objects describing memory locations.
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
Remove Loads Into Fake Uses
This builds on the llvm/ADT/GraphTraits.h file to find the strongly connected components (SCCs) of a ...
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
A manager for alias analyses.
LLVM_ABI ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, bool IgnoreLocals=false)
Returns a bitmask that should be unconditionally applied to the ModRef info of a memory location.
LLVM_ABI MemoryEffects getMemoryEffects(const CallBase *Call)
Return the behavior of the given call site.
Class for arbitrary precision integers.
This templated class represents "all analyses that operate over <aparticular IR unit>" (e....
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
This class represents an incoming formal argument to a Function.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Functions, function parameters, and return types can have attributes to indicate how they should be t...
LLVM_ABI const ConstantRange & getRange() const
Returns the value of the range attribute.
static LLVM_ABI Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
LLVM_ABI ArrayRef< ConstantRange > getValueAsConstantRangeList() const
Return the attribute's value as a ConstantRange array.
static LLVM_ABI Attribute getWithNoFPClass(LLVMContext &Context, FPClassTest Mask)
static LLVM_ABI Attribute getWithCaptureInfo(LLVMContext &Context, CaptureInfo CI)
bool isValid() const
Return true if the attribute is any kind of attribute.
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
LLVM Basic Block Representation.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
Represents analyses that only rely on functions' control flow.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
LLVM_ABI FPClassTest getParamNoFPClass(unsigned i) const
Extract a test mask for disallowed floating-point value classes for the parameter.
LLVM_ABI FPClassTest getRetNoFPClass() const
Extract a test mask for disallowed floating-point value classes for the return value.
LLVM_ABI MemoryEffects getMemoryEffects() const
bool doesNotCapture(unsigned OpNo) const
Determine whether this data operand is not captured.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool hasFnAttr(Attribute::AttrKind Kind) const
Determine whether this call has the given attribute.
bool hasRetAttr(Attribute::AttrKind Kind) const
Determine whether the return value has the given attribute.
unsigned getDataOperandNo(Value::const_user_iterator UI) const
Given a value use iterator, return the data operand corresponding to it.
LLVM_ABI bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Get the attribute of a given kind from a given arg.
bool isByValArgument(unsigned ArgNo) const
Determine whether this argument is passed by value.
bool onlyWritesMemory(unsigned OpNo) const
bool isCallee(Value::const_user_iterator UI) const
Determine whether the passed iterator points to the callee operand's Use.
bool onlyReadsMemory(unsigned OpNo) const
Value * getArgOperand(unsigned i) const
bool isConvergent() const
Determine if the invoke is convergent.
unsigned getArgOperandNo(const Use *U) const
Given a use for a arg operand, get the arg operand number that corresponds to it.
unsigned arg_size() const
bool isArgOperand(const Use *U) const
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Represents which components of the pointer may be captured in which location.
static CaptureInfo none()
Create CaptureInfo that does not capture any components of the pointer.
static CaptureInfo retOnly(CaptureComponents RetComponents=CaptureComponents::All)
Create CaptureInfo that may only capture via the return value.
static CaptureInfo all()
Create CaptureInfo that may capture all components of the pointer.
This class represents a list of constant ranges.
LLVM_ABI void subtract(const ConstantRange &SubRange)
LLVM_ABI void insert(const ConstantRange &NewRange)
Insert a new range to Ranges and keep the list ordered.
bool empty() const
Return true if this list contains no members.
ArrayRef< ConstantRange > rangesRef() const
LLVM_ABI ConstantRangeList intersectWith(const ConstantRangeList &CRL) const
Return the range list that results from the intersection of this ConstantRangeList with another Const...
LLVM_ABI ConstantRangeList unionWith(const ConstantRangeList &CRL) const
Return the range list that results from the union of this ConstantRangeList with another ConstantRang...
This class represents a range of values.
LLVM_ABI bool contains(const APInt &Val) const
Return true if the specified value is in the set.
This is an important base class in LLVM.
A parsed version of the target data layout string in and methods for querying it.
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&...Args)
A proxy from a FunctionAnalysisManager to an SCC.
Function summary information to aid decisions and implementation of importing.
ArrayRef< EdgeTy > calls() const
Return the list of <CalleeValueInfo, CalleeInfo> pairs.
FFlags fflags() const
Get function summary flags.
Function and variable summary information to aid decisions and implementation of importing.
static bool isWeakAnyLinkage(LinkageTypes Linkage)
static bool isLinkOnceAnyLinkage(LinkageTypes Linkage)
static bool isLocalLinkage(LinkageTypes Linkage)
static bool isWeakODRLinkage(LinkageTypes Linkage)
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
static bool isAvailableExternallyLinkage(LinkageTypes Linkage)
static bool isExternalLinkage(LinkageTypes Linkage)
static bool isLinkOnceODRLinkage(LinkageTypes Linkage)
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
bool isKnownNever(FPClassMask Mask) const
Return true if it's known this can never be one of the mask entries.
This is an important class for using LLVM in a threaded context.
An analysis pass which computes the call graph for a module.
A node in the call graph.
A RefSCC of the call graph.
An SCC of the call graph.
A lazily constructed view of the call graph of a module.
LLVM_ABI void buildRefSCCs()
iterator_range< postorder_ref_scc_iterator > postorder_ref_sccs()
MemoryEffectsBase getWithoutLoc(Location Loc) const
Get new MemoryEffectsBase with NoModRef on the given Loc.
bool doesNotAccessMemory() const
Whether this function accesses no memory.
static MemoryEffectsBase argMemOnly(ModRefInfo MR=ModRefInfo::ModRef)
ModRefInfo getModRef(Location Loc) const
Get ModRefInfo for the given Location.
static MemoryEffectsBase none()
static MemoryEffectsBase unknown()
Representation for a specific memory location.
static MemoryLocation getBeforeOrAfter(const Value *Ptr, const AAMDNodes &AATags=AAMDNodes())
Return a location that may access any location before or after Ptr, while remaining within the underl...
static LLVM_ABI std::optional< MemoryLocation > getOrNone(const Instruction *Inst)
Class to hold module path string table and global value map, and encapsulate methods for operating on...
A Module instance is used to store all the information related to an LLVM module.
LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
op_range incoming_values()
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
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.
PreservedAnalyses & preserveSet()
Mark an analysis set as preserved.
PreservedAnalyses & preserve()
Mark an analysis as preserved.
Return a value (possibly void), from a function.
LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
This class represents the LLVM 'select' instruction.
size_type size() const
Determine the number of elements in the SetVector.
void insert_range(Range &&R)
bool insert(const value_type &X)
Insert a new element into the SetVector.
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.
A SetVector that performs no allocations if smaller than a certain size.
typename SuperClass::iterator iterator
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
static unsigned getPointerOperandIndex()
Represent a constant reference to a string, i.e.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isPointerTy() const
True if this is an instance of PointerType.
A Use represents the edge between a Value definition and its users.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI Align getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
constexpr ScalarTy getFixedValue() const
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.
const ParentTy * getParent() const
This class implements an extremely fast bulk output stream that can only output to a stream.
Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool match(Val *V, const Pattern &P)
ap_match< APFloat > m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
initializer< Ty > init(const Ty &Val)
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
constexpr uint64_t PointerSize
aarch64 pointer size.
NodeAddr< UseNode * > Use
NodeAddr< NodeBase * > Node
LLVM_ABI iterator begin() const
This is an optimization pass for GlobalISel generic memory operations.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
bool capturesReadProvenanceOnly(CaptureComponents CC)
LLVM_ABI KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, const SimplifyQuery &SQ, unsigned Depth=0)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
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 succ_empty(const Instruction *I)
LLVM_ABI MemoryEffects computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR)
Returns the memory access properties of this copy of the function.
@ Unknown
Not known to have no common set bits.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
auto successors(const MachineBasicBlock *BB)
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
df_iterator< T > df_begin(const T &G)
scc_iterator< T > scc_begin(const T &G)
Construct the begin iterator for a deduced graph type T.
MemoryEffectsBase< IRMemLocation > MemoryEffects
Summary of how a function affects memory in the program.
LLVM_ABI bool thinLTOPropagateFunctionAttrs(ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing)
Propagate function attributes for function summaries along the index's callgraph during thinlink.
OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P)
Provide wrappers to std::copy_if which take ranges instead of having to pass begin/end explicitly.
AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager
The CGSCC analysis manager.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
const IPOOptions & getIPOOptions(const LLVMContext &C)
auto reverse(ContainerTy &&C)
bool isModSet(const ModRefInfo MRI)
void sort(IteratorTy Start, IteratorTy End)
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
CaptureComponents
Components of the pointer that may be captured.
LLVM_ABI const Value * getUnderlyingObjectAggressive(const Value *V, bool MustPreserveProvenance=false)
Like getUnderlyingObject(), but will try harder to find a single underlying object.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
auto post_order(const T &G)
Post-order traversal of a graph.
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
@ ModRef
The access may reference and may modify the value stored in memory.
@ NoModRef
The access neither references nor modifies the value stored in memory.
@ ArgMem
Access to memory via argument pointers.
LLVM_ABI bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures, unsigned MaxUsesToExplore=0)
PointerMayBeCaptured - Return true if this pointer value may be captured by the enclosing function (w...
LLVM_ABI bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
LLVM_ABI bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
bool capturesAnything(CaptureComponents CC)
df_iterator< T > df_end(const T &G)
LLVM_ABI bool inferAttributesFromOthers(Function &F)
If we can infer one attribute from another on the declaration of a function, explicitly materialize t...
LLVM_ABI UseCaptureInfo DetermineUseCaptureKind(const Use &U, const Value *Base)
Determine what kind of capture behaviour U may exhibit.
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
bool capturesAll(CaptureComponents CC)
@ End
Run the machine verifier once, at the end of the pipeline.
bool capturesNothing(CaptureComponents CC)
bool isNoModRef(const ModRefInfo MRI)
LLVM_ABI void FindFunctionBackedges(const Function &F, SmallVectorImpl< std::pair< const BasicBlock *, const BasicBlock * > > &Result)
Analyze the specified function to find all of the loop backedges in the function and return them.
LLVM_ABI bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
bool capturesAnyProvenance(CaptureComponents CC)
bool isRefSet(const ModRefInfo MRI)
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
LLVM_ABI bool canReturn(const Function &F)
Return true if there is at least a path through which F can return, false if there is no such path.
LLVM_ABI ConstantRange computeConstantRange(const Value *V, bool ForSigned, const SimplifyQuery &SQ, unsigned Depth=0)
Determine the possible constant range of an integer or vector of integer value.
This struct is a compact representation of a valid (non-zero power of two) alignment.
static ArgAccessProperties all()
ArgAccessProperties & operator|=(const ArgAccessProperties &Other)
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
This callback is used in conjunction with PointerMayBeCaptured.
Flags specific to function summaries.
SmallVectorImpl< ArgumentGraphNode * >::iterator ChildIteratorType
static ChildIteratorType child_begin(NodeRef N)
static ChildIteratorType child_end(NodeRef N)
ArgumentGraphNode * NodeRef
static NodeRef getEntryNode(NodeRef A)
static ChildIteratorType nodes_end(ArgumentGraph *AG)
static NodeRef getEntryNode(ArgumentGraph *AG)
static ChildIteratorType nodes_begin(ArgumentGraph *AG)
typename ArgumentGraph *::UnknownGraphTypeError NodeRef
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
LLVM_ABI PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)
LLVM_ABI void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
Capture information for a specific Use.
CaptureComponents UseCC
Components captured by this use.
Struct that holds a reference to a particular GUID in a global value summary.