1 //===- FunctionAttrs.cpp - Pass which marks functions attributes ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements a simple interprocedural pass which walks the
11 // call-graph, looking for functions which do not access or only read
12 // non-local memory, and marking them readnone/readonly. It does the
13 // same with function arguments independently, marking them readonly/
14 // readnone/nocapture. Finally, well-known library call declarations
15 // are marked with all attributes that are consistent with the
16 // function's standard definition. This pass is implemented as a
17 // bottom-up traversal of the call-graph.
19 //===----------------------------------------------------------------------===//
21 #include "llvm/Transforms/IPO.h"
22 #include "llvm/ADT/SCCIterator.h"
23 #include "llvm/ADT/SetVector.h"
24 #include "llvm/ADT/SmallSet.h"
25 #include "llvm/ADT/Statistic.h"
26 #include "llvm/Analysis/AliasAnalysis.h"
27 #include "llvm/Analysis/AssumptionCache.h"
28 #include "llvm/Analysis/BasicAliasAnalysis.h"
29 #include "llvm/Analysis/CallGraph.h"
30 #include "llvm/Analysis/CallGraphSCCPass.h"
31 #include "llvm/Analysis/CaptureTracking.h"
32 #include "llvm/Analysis/TargetLibraryInfo.h"
33 #include "llvm/Analysis/ValueTracking.h"
34 #include "llvm/IR/GlobalVariable.h"
35 #include "llvm/IR/InstIterator.h"
36 #include "llvm/IR/IntrinsicInst.h"
37 #include "llvm/IR/LLVMContext.h"
38 #include "llvm/Support/Debug.h"
39 #include "llvm/Support/raw_ostream.h"
40 #include "llvm/Analysis/TargetLibraryInfo.h"
43 #define DEBUG_TYPE "functionattrs"
45 STATISTIC(NumReadNone, "Number of functions marked readnone");
46 STATISTIC(NumReadOnly, "Number of functions marked readonly");
47 STATISTIC(NumNoCapture, "Number of arguments marked nocapture");
48 STATISTIC(NumReadNoneArg, "Number of arguments marked readnone");
49 STATISTIC(NumReadOnlyArg, "Number of arguments marked readonly");
50 STATISTIC(NumNoAlias, "Number of function returns marked noalias");
51 STATISTIC(NumNonNullReturn, "Number of function returns marked nonnull");
52 STATISTIC(NumAnnotated, "Number of attributes added to library functions");
55 struct FunctionAttrs : public CallGraphSCCPass {
56 static char ID; // Pass identification, replacement for typeid
57 FunctionAttrs() : CallGraphSCCPass(ID) {
58 initializeFunctionAttrsPass(*PassRegistry::getPassRegistry());
61 bool runOnSCC(CallGraphSCC &SCC) override;
63 void getAnalysisUsage(AnalysisUsage &AU) const override {
65 AU.addRequired<AssumptionCacheTracker>();
66 AU.addRequired<TargetLibraryInfoWrapperPass>();
67 CallGraphSCCPass::getAnalysisUsage(AU);
71 TargetLibraryInfo *TLI;
73 bool AddReadAttrs(const CallGraphSCC &SCC);
74 bool AddArgumentAttrs(const CallGraphSCC &SCC);
75 bool AddNoAliasAttrs(const CallGraphSCC &SCC);
76 bool AddNonNullAttrs(const CallGraphSCC &SCC);
77 bool annotateLibraryCalls(const CallGraphSCC &SCC);
81 char FunctionAttrs::ID = 0;
82 INITIALIZE_PASS_BEGIN(FunctionAttrs, "functionattrs",
83 "Deduce function attributes", false, false)
84 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
85 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
86 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
87 INITIALIZE_PASS_END(FunctionAttrs, "functionattrs",
88 "Deduce function attributes", false, false)
90 Pass *llvm::createFunctionAttrsPass() { return new FunctionAttrs(); }
93 /// The three kinds of memory access relevant to 'readonly' and
94 /// 'readnone' attributes.
95 enum MemoryAccessKind {
102 static MemoryAccessKind
103 checkFunctionMemoryAccess(Function &F, AAResults &AAR,
104 const SmallPtrSetImpl<Function *> &SCCNodes) {
105 FunctionModRefBehavior MRB = AAR.getModRefBehavior(&F);
106 if (MRB == FMRB_DoesNotAccessMemory)
110 // Definitions with weak linkage may be overridden at linktime with
111 // something that writes memory, so treat them like declarations.
112 if (F.isDeclaration() || F.mayBeOverridden()) {
113 if (AliasAnalysis::onlyReadsMemory(MRB))
116 // Conservatively assume it writes to memory.
120 // Scan the function body for instructions that may read or write memory.
121 bool ReadsMemory = false;
122 for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) {
123 Instruction *I = &*II;
125 // Some instructions can be ignored even if they read or write memory.
126 // Detect these now, skipping to the next instruction if one is found.
127 CallSite CS(cast<Value>(I));
129 // Ignore calls to functions in the same SCC.
130 if (CS.getCalledFunction() && SCCNodes.count(CS.getCalledFunction()))
132 FunctionModRefBehavior MRB = AAR.getModRefBehavior(CS);
133 // If the call doesn't access arbitrary memory, we may be able to
134 // figure out something.
135 if (AliasAnalysis::onlyAccessesArgPointees(MRB)) {
136 // If the call does access argument pointees, check each argument.
137 if (AliasAnalysis::doesAccessArgPointees(MRB))
138 // Check whether all pointer arguments point to local memory, and
139 // ignore calls that only access local memory.
140 for (CallSite::arg_iterator CI = CS.arg_begin(), CE = CS.arg_end();
143 if (Arg->getType()->isPointerTy()) {
145 I->getAAMetadata(AAInfo);
147 MemoryLocation Loc(Arg, MemoryLocation::UnknownSize, AAInfo);
148 if (!AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true)) {
150 // Writes non-local memory. Give up.
153 // Ok, it reads non-local memory.
160 // The call could access any memory. If that includes writes, give up.
163 // If it reads, note it.
167 } else if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
168 // Ignore non-volatile loads from local memory. (Atomic is okay here.)
169 if (!LI->isVolatile()) {
170 MemoryLocation Loc = MemoryLocation::get(LI);
171 if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
174 } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
175 // Ignore non-volatile stores to local memory. (Atomic is okay here.)
176 if (!SI->isVolatile()) {
177 MemoryLocation Loc = MemoryLocation::get(SI);
178 if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
181 } else if (VAArgInst *VI = dyn_cast<VAArgInst>(I)) {
182 // Ignore vaargs on local memory.
183 MemoryLocation Loc = MemoryLocation::get(VI);
184 if (AAR.pointsToConstantMemory(Loc, /*OrLocal=*/true))
188 // Any remaining instructions need to be taken seriously! Check if they
189 // read or write memory.
190 if (I->mayWriteToMemory())
191 // Writes memory. Just give up.
194 // If this instruction may read memory, remember that.
195 ReadsMemory |= I->mayReadFromMemory();
198 return ReadsMemory ? MAK_ReadOnly : MAK_ReadNone;
201 /// Deduce readonly/readnone attributes for the SCC.
202 bool FunctionAttrs::AddReadAttrs(const CallGraphSCC &SCC) {
203 SmallPtrSet<Function *, 8> SCCNodes;
205 // Fill SCCNodes with the elements of the SCC. Used for quickly
206 // looking up whether a given CallGraphNode is in this SCC.
207 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I)
208 SCCNodes.insert((*I)->getFunction());
210 // Check if any of the functions in the SCC read or write memory. If they
211 // write memory then they can't be marked readnone or readonly.
212 bool ReadsMemory = false;
213 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
214 Function *F = (*I)->getFunction();
216 if (!F || F->hasFnAttribute(Attribute::OptimizeNone))
217 // External node or node we don't want to optimize - assume it may write
218 // memory and give up.
221 // We need to manually construct BasicAA directly in order to disable its
222 // use of other function analyses.
223 BasicAAResult BAR(createLegacyPMBasicAAResult(*this, *F));
225 // Construct our own AA results for this function. We do this manually to
226 // work around the limitations of the legacy pass manager.
227 AAResults AAR(createLegacyPMAAResults(*this, *F, BAR));
229 switch (checkFunctionMemoryAccess(*F, AAR, SCCNodes)) {
241 // Success! Functions in this SCC do not access memory, or only read memory.
242 // Give them the appropriate attribute.
243 bool MadeChange = false;
244 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
245 Function *F = (*I)->getFunction();
247 if (F->doesNotAccessMemory())
251 if (F->onlyReadsMemory() && ReadsMemory)
257 // Clear out any existing attributes.
259 B.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
261 AttributeSet::FunctionIndex,
262 AttributeSet::get(F->getContext(), AttributeSet::FunctionIndex, B));
264 // Add in the new attribute.
265 F->addAttribute(AttributeSet::FunctionIndex,
266 ReadsMemory ? Attribute::ReadOnly : Attribute::ReadNone);
278 /// For a given pointer Argument, this retains a list of Arguments of functions
279 /// in the same SCC that the pointer data flows into. We use this to build an
280 /// SCC of the arguments.
281 struct ArgumentGraphNode {
282 Argument *Definition;
283 SmallVector<ArgumentGraphNode *, 4> Uses;
286 class ArgumentGraph {
287 // We store pointers to ArgumentGraphNode objects, so it's important that
288 // that they not move around upon insert.
289 typedef std::map<Argument *, ArgumentGraphNode> ArgumentMapTy;
291 ArgumentMapTy ArgumentMap;
293 // There is no root node for the argument graph, in fact:
294 // void f(int *x, int *y) { if (...) f(x, y); }
295 // is an example where the graph is disconnected. The SCCIterator requires a
296 // single entry point, so we maintain a fake ("synthetic") root node that
297 // uses every node. Because the graph is directed and nothing points into
298 // the root, it will not participate in any SCCs (except for its own).
299 ArgumentGraphNode SyntheticRoot;
302 ArgumentGraph() { SyntheticRoot.Definition = nullptr; }
304 typedef SmallVectorImpl<ArgumentGraphNode *>::iterator iterator;
306 iterator begin() { return SyntheticRoot.Uses.begin(); }
307 iterator end() { return SyntheticRoot.Uses.end(); }
308 ArgumentGraphNode *getEntryNode() { return &SyntheticRoot; }
310 ArgumentGraphNode *operator[](Argument *A) {
311 ArgumentGraphNode &Node = ArgumentMap[A];
313 SyntheticRoot.Uses.push_back(&Node);
318 /// This tracker checks whether callees are in the SCC, and if so it does not
319 /// consider that a capture, instead adding it to the "Uses" list and
320 /// continuing with the analysis.
321 struct ArgumentUsesTracker : public CaptureTracker {
322 ArgumentUsesTracker(const SmallPtrSet<Function *, 8> &SCCNodes)
323 : Captured(false), SCCNodes(SCCNodes) {}
325 void tooManyUses() override { Captured = true; }
327 bool captured(const Use *U) override {
328 CallSite CS(U->getUser());
329 if (!CS.getInstruction()) {
334 Function *F = CS.getCalledFunction();
335 if (!F || !SCCNodes.count(F)) {
341 Function::arg_iterator AI = F->arg_begin(), AE = F->arg_end();
342 for (CallSite::arg_iterator PI = CS.arg_begin(), PE = CS.arg_end();
343 PI != PE; ++PI, ++AI) {
345 assert(F->isVarArg() && "More params than args in non-varargs call");
355 assert(Found && "Capturing call-site captured nothing?");
360 bool Captured; // True only if certainly captured (used outside our SCC).
361 SmallVector<Argument *, 4> Uses; // Uses within our SCC.
363 const SmallPtrSet<Function *, 8> &SCCNodes;
368 template <> struct GraphTraits<ArgumentGraphNode *> {
369 typedef ArgumentGraphNode NodeType;
370 typedef SmallVectorImpl<ArgumentGraphNode *>::iterator ChildIteratorType;
372 static inline NodeType *getEntryNode(NodeType *A) { return A; }
373 static inline ChildIteratorType child_begin(NodeType *N) {
374 return N->Uses.begin();
376 static inline ChildIteratorType child_end(NodeType *N) {
377 return N->Uses.end();
381 struct GraphTraits<ArgumentGraph *> : public GraphTraits<ArgumentGraphNode *> {
382 static NodeType *getEntryNode(ArgumentGraph *AG) {
383 return AG->getEntryNode();
385 static ChildIteratorType nodes_begin(ArgumentGraph *AG) {
388 static ChildIteratorType nodes_end(ArgumentGraph *AG) { return AG->end(); }
392 /// Returns Attribute::None, Attribute::ReadOnly or Attribute::ReadNone.
393 static Attribute::AttrKind
394 determinePointerReadAttrs(Argument *A,
395 const SmallPtrSet<Argument *, 8> &SCCNodes) {
397 SmallVector<Use *, 32> Worklist;
398 SmallSet<Use *, 32> Visited;
400 // inalloca arguments are always clobbered by the call.
401 if (A->hasInAllocaAttr())
402 return Attribute::None;
405 // We don't need to track IsWritten. If A is written to, return immediately.
407 for (Use &U : A->uses()) {
409 Worklist.push_back(&U);
412 while (!Worklist.empty()) {
413 Use *U = Worklist.pop_back_val();
414 Instruction *I = cast<Instruction>(U->getUser());
417 switch (I->getOpcode()) {
418 case Instruction::BitCast:
419 case Instruction::GetElementPtr:
420 case Instruction::PHI:
421 case Instruction::Select:
422 case Instruction::AddrSpaceCast:
423 // The original value is not read/written via this if the new value isn't.
424 for (Use &UU : I->uses())
425 if (Visited.insert(&UU).second)
426 Worklist.push_back(&UU);
429 case Instruction::Call:
430 case Instruction::Invoke: {
431 bool Captures = true;
433 if (I->getType()->isVoidTy())
436 auto AddUsersToWorklistIfCapturing = [&] {
438 for (Use &UU : I->uses())
439 if (Visited.insert(&UU).second)
440 Worklist.push_back(&UU);
444 if (CS.doesNotAccessMemory()) {
445 AddUsersToWorklistIfCapturing();
449 Function *F = CS.getCalledFunction();
451 if (CS.onlyReadsMemory()) {
453 AddUsersToWorklistIfCapturing();
456 return Attribute::None;
459 Function::arg_iterator AI = F->arg_begin(), AE = F->arg_end();
460 CallSite::arg_iterator B = CS.arg_begin(), E = CS.arg_end();
461 for (CallSite::arg_iterator A = B; A != E; ++A, ++AI) {
464 assert(F->isVarArg() &&
465 "More params than args in non-varargs call.");
466 return Attribute::None;
468 Captures &= !CS.doesNotCapture(A - B);
469 if (SCCNodes.count(AI))
471 if (!CS.onlyReadsMemory() && !CS.onlyReadsMemory(A - B))
472 return Attribute::None;
473 if (!CS.doesNotAccessMemory(A - B))
477 AddUsersToWorklistIfCapturing();
481 case Instruction::Load:
485 case Instruction::ICmp:
486 case Instruction::Ret:
490 return Attribute::None;
494 return IsRead ? Attribute::ReadOnly : Attribute::ReadNone;
497 /// Deduce nocapture attributes for the SCC.
498 bool FunctionAttrs::AddArgumentAttrs(const CallGraphSCC &SCC) {
499 bool Changed = false;
501 SmallPtrSet<Function *, 8> SCCNodes;
503 // Fill SCCNodes with the elements of the SCC. Used for quickly
504 // looking up whether a given CallGraphNode is in this SCC.
505 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
506 Function *F = (*I)->getFunction();
507 if (F && !F->isDeclaration() && !F->mayBeOverridden() &&
508 !F->hasFnAttribute(Attribute::OptimizeNone))
515 B.addAttribute(Attribute::NoCapture);
517 // Check each function in turn, determining which pointer arguments are not
519 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
520 Function *F = (*I)->getFunction();
522 if (!F || F->hasFnAttribute(Attribute::OptimizeNone))
523 // External node or function we're trying not to optimize - only a problem
524 // for arguments that we pass to it.
527 // Definitions with weak linkage may be overridden at linktime with
528 // something that captures pointers, so treat them like declarations.
529 if (F->isDeclaration() || F->mayBeOverridden())
532 // Functions that are readonly (or readnone) and nounwind and don't return
533 // a value can't capture arguments. Don't analyze them.
534 if (F->onlyReadsMemory() && F->doesNotThrow() &&
535 F->getReturnType()->isVoidTy()) {
536 for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
538 if (A->getType()->isPointerTy() && !A->hasNoCaptureAttr()) {
539 A->addAttr(AttributeSet::get(F->getContext(), A->getArgNo() + 1, B));
547 for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
549 if (!A->getType()->isPointerTy())
551 bool HasNonLocalUses = false;
552 if (!A->hasNoCaptureAttr()) {
553 ArgumentUsesTracker Tracker(SCCNodes);
554 PointerMayBeCaptured(A, &Tracker);
555 if (!Tracker.Captured) {
556 if (Tracker.Uses.empty()) {
557 // If it's trivially not captured, mark it nocapture now.
559 AttributeSet::get(F->getContext(), A->getArgNo() + 1, B));
563 // If it's not trivially captured and not trivially not captured,
564 // then it must be calling into another function in our SCC. Save
565 // its particulars for Argument-SCC analysis later.
566 ArgumentGraphNode *Node = AG[A];
567 for (SmallVectorImpl<Argument *>::iterator
568 UI = Tracker.Uses.begin(),
569 UE = Tracker.Uses.end();
571 Node->Uses.push_back(AG[*UI]);
573 HasNonLocalUses = true;
577 // Otherwise, it's captured. Don't bother doing SCC analysis on it.
579 if (!HasNonLocalUses && !A->onlyReadsMemory()) {
580 // Can we determine that it's readonly/readnone without doing an SCC?
581 // Note that we don't allow any calls at all here, or else our result
582 // will be dependent on the iteration order through the functions in the
584 SmallPtrSet<Argument *, 8> Self;
586 Attribute::AttrKind R = determinePointerReadAttrs(A, Self);
587 if (R != Attribute::None) {
590 A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
592 R == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg;
598 // The graph we've collected is partial because we stopped scanning for
599 // argument uses once we solved the argument trivially. These partial nodes
600 // show up as ArgumentGraphNode objects with an empty Uses list, and for
601 // these nodes the final decision about whether they capture has already been
602 // made. If the definition doesn't have a 'nocapture' attribute by now, it
605 for (scc_iterator<ArgumentGraph *> I = scc_begin(&AG); !I.isAtEnd(); ++I) {
606 const std::vector<ArgumentGraphNode *> &ArgumentSCC = *I;
607 if (ArgumentSCC.size() == 1) {
608 if (!ArgumentSCC[0]->Definition)
609 continue; // synthetic root node
611 // eg. "void f(int* x) { if (...) f(x); }"
612 if (ArgumentSCC[0]->Uses.size() == 1 &&
613 ArgumentSCC[0]->Uses[0] == ArgumentSCC[0]) {
614 Argument *A = ArgumentSCC[0]->Definition;
615 A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
622 bool SCCCaptured = false;
623 for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end();
624 I != E && !SCCCaptured; ++I) {
625 ArgumentGraphNode *Node = *I;
626 if (Node->Uses.empty()) {
627 if (!Node->Definition->hasNoCaptureAttr())
634 SmallPtrSet<Argument *, 8> ArgumentSCCNodes;
635 // Fill ArgumentSCCNodes with the elements of the ArgumentSCC. Used for
636 // quickly looking up whether a given Argument is in this ArgumentSCC.
637 for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end(); I != E; ++I) {
638 ArgumentSCCNodes.insert((*I)->Definition);
641 for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end();
642 I != E && !SCCCaptured; ++I) {
643 ArgumentGraphNode *N = *I;
644 for (SmallVectorImpl<ArgumentGraphNode *>::iterator UI = N->Uses.begin(),
647 Argument *A = (*UI)->Definition;
648 if (A->hasNoCaptureAttr() || ArgumentSCCNodes.count(A))
657 for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
658 Argument *A = ArgumentSCC[i]->Definition;
659 A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
664 // We also want to compute readonly/readnone. With a small number of false
665 // negatives, we can assume that any pointer which is captured isn't going
666 // to be provably readonly or readnone, since by definition we can't
667 // analyze all uses of a captured pointer.
669 // The false negatives happen when the pointer is captured by a function
670 // that promises readonly/readnone behaviour on the pointer, then the
671 // pointer's lifetime ends before anything that writes to arbitrary memory.
672 // Also, a readonly/readnone pointer may be returned, but returning a
673 // pointer is capturing it.
675 Attribute::AttrKind ReadAttr = Attribute::ReadNone;
676 for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
677 Argument *A = ArgumentSCC[i]->Definition;
678 Attribute::AttrKind K = determinePointerReadAttrs(A, ArgumentSCCNodes);
679 if (K == Attribute::ReadNone)
681 if (K == Attribute::ReadOnly) {
682 ReadAttr = Attribute::ReadOnly;
689 if (ReadAttr != Attribute::None) {
691 B.addAttribute(ReadAttr);
692 R.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
693 for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
694 Argument *A = ArgumentSCC[i]->Definition;
695 // Clear out existing readonly/readnone attributes
696 A->removeAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, R));
697 A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B));
698 ReadAttr == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg;
707 /// Tests whether a function is "malloc-like".
709 /// A function is "malloc-like" if it returns either null or a pointer that
710 /// doesn't alias any other pointer visible to the caller.
711 static bool isFunctionMallocLike(Function *F,
712 SmallPtrSet<Function *, 8> &SCCNodes) {
713 SmallSetVector<Value *, 8> FlowsToReturn;
714 for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)
715 if (ReturnInst *Ret = dyn_cast<ReturnInst>(I->getTerminator()))
716 FlowsToReturn.insert(Ret->getReturnValue());
718 for (unsigned i = 0; i != FlowsToReturn.size(); ++i) {
719 Value *RetVal = FlowsToReturn[i];
721 if (Constant *C = dyn_cast<Constant>(RetVal)) {
722 if (!C->isNullValue() && !isa<UndefValue>(C))
728 if (isa<Argument>(RetVal))
731 if (Instruction *RVI = dyn_cast<Instruction>(RetVal))
732 switch (RVI->getOpcode()) {
733 // Extend the analysis by looking upwards.
734 case Instruction::BitCast:
735 case Instruction::GetElementPtr:
736 case Instruction::AddrSpaceCast:
737 FlowsToReturn.insert(RVI->getOperand(0));
739 case Instruction::Select: {
740 SelectInst *SI = cast<SelectInst>(RVI);
741 FlowsToReturn.insert(SI->getTrueValue());
742 FlowsToReturn.insert(SI->getFalseValue());
745 case Instruction::PHI: {
746 PHINode *PN = cast<PHINode>(RVI);
747 for (Value *IncValue : PN->incoming_values())
748 FlowsToReturn.insert(IncValue);
752 // Check whether the pointer came from an allocation.
753 case Instruction::Alloca:
755 case Instruction::Call:
756 case Instruction::Invoke: {
758 if (CS.paramHasAttr(0, Attribute::NoAlias))
760 if (CS.getCalledFunction() && SCCNodes.count(CS.getCalledFunction()))
764 return false; // Did not come from an allocation.
767 if (PointerMayBeCaptured(RetVal, false, /*StoreCaptures=*/false))
774 /// Deduce noalias attributes for the SCC.
775 bool FunctionAttrs::AddNoAliasAttrs(const CallGraphSCC &SCC) {
776 SmallPtrSet<Function *, 8> SCCNodes;
778 // Fill SCCNodes with the elements of the SCC. Used for quickly
779 // looking up whether a given CallGraphNode is in this SCC.
780 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I)
781 SCCNodes.insert((*I)->getFunction());
783 // Check each function in turn, determining which functions return noalias
785 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
786 Function *F = (*I)->getFunction();
788 if (!F || F->hasFnAttribute(Attribute::OptimizeNone))
789 // External node or node we don't want to optimize - skip it;
793 if (F->doesNotAlias(0))
796 // Definitions with weak linkage may be overridden at linktime, so
797 // treat them like declarations.
798 if (F->isDeclaration() || F->mayBeOverridden())
801 // We annotate noalias return values, which are only applicable to
803 if (!F->getReturnType()->isPointerTy())
806 if (!isFunctionMallocLike(F, SCCNodes))
810 bool MadeChange = false;
811 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
812 Function *F = (*I)->getFunction();
813 if (F->doesNotAlias(0) || !F->getReturnType()->isPointerTy())
816 F->setDoesNotAlias(0);
824 /// Tests whether this function is known to not return null.
826 /// Requires that the function returns a pointer.
828 /// Returns true if it believes the function will not return a null, and sets
829 /// \p Speculative based on whether the returned conclusion is a speculative
830 /// conclusion due to SCC calls.
831 static bool isReturnNonNull(Function *F, SmallPtrSet<Function *, 8> &SCCNodes,
832 const TargetLibraryInfo &TLI, bool &Speculative) {
833 assert(F->getReturnType()->isPointerTy() &&
834 "nonnull only meaningful on pointer types");
837 SmallSetVector<Value *, 8> FlowsToReturn;
838 for (BasicBlock &BB : *F)
839 if (auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator()))
840 FlowsToReturn.insert(Ret->getReturnValue());
842 for (unsigned i = 0; i != FlowsToReturn.size(); ++i) {
843 Value *RetVal = FlowsToReturn[i];
845 // If this value is locally known to be non-null, we're good
846 if (isKnownNonNull(RetVal, &TLI))
849 // Otherwise, we need to look upwards since we can't make any local
851 Instruction *RVI = dyn_cast<Instruction>(RetVal);
854 switch (RVI->getOpcode()) {
855 // Extend the analysis by looking upwards.
856 case Instruction::BitCast:
857 case Instruction::GetElementPtr:
858 case Instruction::AddrSpaceCast:
859 FlowsToReturn.insert(RVI->getOperand(0));
861 case Instruction::Select: {
862 SelectInst *SI = cast<SelectInst>(RVI);
863 FlowsToReturn.insert(SI->getTrueValue());
864 FlowsToReturn.insert(SI->getFalseValue());
867 case Instruction::PHI: {
868 PHINode *PN = cast<PHINode>(RVI);
869 for (int i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
870 FlowsToReturn.insert(PN->getIncomingValue(i));
873 case Instruction::Call:
874 case Instruction::Invoke: {
876 Function *Callee = CS.getCalledFunction();
877 // A call to a node within the SCC is assumed to return null until
879 if (Callee && SCCNodes.count(Callee)) {
886 return false; // Unknown source, may be null
888 llvm_unreachable("should have either continued or returned");
894 /// Deduce nonnull attributes for the SCC.
895 bool FunctionAttrs::AddNonNullAttrs(const CallGraphSCC &SCC) {
896 SmallPtrSet<Function *, 8> SCCNodes;
898 // Fill SCCNodes with the elements of the SCC. Used for quickly
899 // looking up whether a given CallGraphNode is in this SCC.
900 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I)
901 SCCNodes.insert((*I)->getFunction());
903 // Speculative that all functions in the SCC return only nonnull
904 // pointers. We may refute this as we analyze functions.
905 bool SCCReturnsNonNull = true;
907 bool MadeChange = false;
909 // Check each function in turn, determining which functions return nonnull
911 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
912 Function *F = (*I)->getFunction();
914 if (!F || F->hasFnAttribute(Attribute::OptimizeNone))
915 // External node or node we don't want to optimize - skip it;
919 if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
923 // Definitions with weak linkage may be overridden at linktime, so
924 // treat them like declarations.
925 if (F->isDeclaration() || F->mayBeOverridden())
928 // We annotate nonnull return values, which are only applicable to
930 if (!F->getReturnType()->isPointerTy())
933 bool Speculative = false;
934 if (isReturnNonNull(F, SCCNodes, *TLI, Speculative)) {
936 // Mark the function eagerly since we may discover a function
937 // which prevents us from speculating about the entire SCC
938 DEBUG(dbgs() << "Eagerly marking " << F->getName() << " as nonnull\n");
939 F->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull);
945 // At least one function returns something which could be null, can't
946 // speculate any more.
947 SCCReturnsNonNull = false;
950 if (SCCReturnsNonNull) {
951 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
952 Function *F = (*I)->getFunction();
953 if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
954 Attribute::NonNull) ||
955 !F->getReturnType()->isPointerTy())
958 DEBUG(dbgs() << "SCC marking " << F->getName() << " as nonnull\n");
959 F->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull);
968 static void setDoesNotAccessMemory(Function &F) {
969 if (!F.doesNotAccessMemory()) {
970 F.setDoesNotAccessMemory();
975 static void setOnlyReadsMemory(Function &F) {
976 if (!F.onlyReadsMemory()) {
977 F.setOnlyReadsMemory();
982 static void setDoesNotThrow(Function &F) {
983 if (!F.doesNotThrow()) {
989 static void setDoesNotCapture(Function &F, unsigned n) {
990 if (!F.doesNotCapture(n)) {
991 F.setDoesNotCapture(n);
996 static void setOnlyReadsMemory(Function &F, unsigned n) {
997 if (!F.onlyReadsMemory(n)) {
998 F.setOnlyReadsMemory(n);
1003 static void setDoesNotAlias(Function &F, unsigned n) {
1004 if (!F.doesNotAlias(n)) {
1005 F.setDoesNotAlias(n);
1010 /// Analyze the name and prototype of the given function and set any applicable
1013 /// Returns true if any attributes were set and false otherwise.
1014 static bool inferPrototypeAttributes(Function &F, const TargetLibraryInfo &TLI) {
1015 if (F.hasFnAttribute(Attribute::OptimizeNone))
1018 FunctionType *FTy = F.getFunctionType();
1019 LibFunc::Func TheLibFunc;
1020 if (!(TLI.getLibFunc(F.getName(), TheLibFunc) && TLI.has(TheLibFunc)))
1023 switch (TheLibFunc) {
1024 case LibFunc::strlen:
1025 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1027 setOnlyReadsMemory(F);
1029 setDoesNotCapture(F, 1);
1031 case LibFunc::strchr:
1032 case LibFunc::strrchr:
1033 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy() ||
1034 !FTy->getParamType(1)->isIntegerTy())
1036 setOnlyReadsMemory(F);
1039 case LibFunc::strtol:
1040 case LibFunc::strtod:
1041 case LibFunc::strtof:
1042 case LibFunc::strtoul:
1043 case LibFunc::strtoll:
1044 case LibFunc::strtold:
1045 case LibFunc::strtoull:
1046 if (FTy->getNumParams() < 2 || !FTy->getParamType(1)->isPointerTy())
1049 setDoesNotCapture(F, 2);
1050 setOnlyReadsMemory(F, 1);
1052 case LibFunc::strcpy:
1053 case LibFunc::stpcpy:
1054 case LibFunc::strcat:
1055 case LibFunc::strncat:
1056 case LibFunc::strncpy:
1057 case LibFunc::stpncpy:
1058 if (FTy->getNumParams() < 2 || !FTy->getParamType(1)->isPointerTy())
1061 setDoesNotCapture(F, 2);
1062 setOnlyReadsMemory(F, 2);
1064 case LibFunc::strxfrm:
1065 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy() ||
1066 !FTy->getParamType(1)->isPointerTy())
1069 setDoesNotCapture(F, 1);
1070 setDoesNotCapture(F, 2);
1071 setOnlyReadsMemory(F, 2);
1073 case LibFunc::strcmp: // 0,1
1074 case LibFunc::strspn: // 0,1
1075 case LibFunc::strncmp: // 0,1
1076 case LibFunc::strcspn: // 0,1
1077 case LibFunc::strcoll: // 0,1
1078 case LibFunc::strcasecmp: // 0,1
1079 case LibFunc::strncasecmp: //
1080 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1081 !FTy->getParamType(1)->isPointerTy())
1083 setOnlyReadsMemory(F);
1085 setDoesNotCapture(F, 1);
1086 setDoesNotCapture(F, 2);
1088 case LibFunc::strstr:
1089 case LibFunc::strpbrk:
1090 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1092 setOnlyReadsMemory(F);
1094 setDoesNotCapture(F, 2);
1096 case LibFunc::strtok:
1097 case LibFunc::strtok_r:
1098 if (FTy->getNumParams() < 2 || !FTy->getParamType(1)->isPointerTy())
1101 setDoesNotCapture(F, 2);
1102 setOnlyReadsMemory(F, 2);
1104 case LibFunc::scanf:
1105 if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy())
1108 setDoesNotCapture(F, 1);
1109 setOnlyReadsMemory(F, 1);
1111 case LibFunc::setbuf:
1112 case LibFunc::setvbuf:
1113 if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy())
1116 setDoesNotCapture(F, 1);
1118 case LibFunc::strdup:
1119 case LibFunc::strndup:
1120 if (FTy->getNumParams() < 1 || !FTy->getReturnType()->isPointerTy() ||
1121 !FTy->getParamType(0)->isPointerTy())
1124 setDoesNotAlias(F, 0);
1125 setDoesNotCapture(F, 1);
1126 setOnlyReadsMemory(F, 1);
1129 case LibFunc::statvfs:
1130 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1131 !FTy->getParamType(1)->isPointerTy())
1134 setDoesNotCapture(F, 1);
1135 setDoesNotCapture(F, 2);
1136 setOnlyReadsMemory(F, 1);
1138 case LibFunc::sscanf:
1139 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1140 !FTy->getParamType(1)->isPointerTy())
1143 setDoesNotCapture(F, 1);
1144 setDoesNotCapture(F, 2);
1145 setOnlyReadsMemory(F, 1);
1146 setOnlyReadsMemory(F, 2);
1148 case LibFunc::sprintf:
1149 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1150 !FTy->getParamType(1)->isPointerTy())
1153 setDoesNotCapture(F, 1);
1154 setDoesNotCapture(F, 2);
1155 setOnlyReadsMemory(F, 2);
1157 case LibFunc::snprintf:
1158 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy() ||
1159 !FTy->getParamType(2)->isPointerTy())
1162 setDoesNotCapture(F, 1);
1163 setDoesNotCapture(F, 3);
1164 setOnlyReadsMemory(F, 3);
1166 case LibFunc::setitimer:
1167 if (FTy->getNumParams() != 3 || !FTy->getParamType(1)->isPointerTy() ||
1168 !FTy->getParamType(2)->isPointerTy())
1171 setDoesNotCapture(F, 2);
1172 setDoesNotCapture(F, 3);
1173 setOnlyReadsMemory(F, 2);
1175 case LibFunc::system:
1176 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1178 // May throw; "system" is a valid pthread cancellation point.
1179 setDoesNotCapture(F, 1);
1180 setOnlyReadsMemory(F, 1);
1182 case LibFunc::malloc:
1183 if (FTy->getNumParams() != 1 || !FTy->getReturnType()->isPointerTy())
1186 setDoesNotAlias(F, 0);
1188 case LibFunc::memcmp:
1189 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy() ||
1190 !FTy->getParamType(1)->isPointerTy())
1192 setOnlyReadsMemory(F);
1194 setDoesNotCapture(F, 1);
1195 setDoesNotCapture(F, 2);
1197 case LibFunc::memchr:
1198 case LibFunc::memrchr:
1199 if (FTy->getNumParams() != 3)
1201 setOnlyReadsMemory(F);
1205 case LibFunc::modff:
1206 case LibFunc::modfl:
1207 if (FTy->getNumParams() < 2 || !FTy->getParamType(1)->isPointerTy())
1210 setDoesNotCapture(F, 2);
1212 case LibFunc::memcpy:
1213 case LibFunc::memccpy:
1214 case LibFunc::memmove:
1215 if (FTy->getNumParams() < 2 || !FTy->getParamType(1)->isPointerTy())
1218 setDoesNotCapture(F, 2);
1219 setOnlyReadsMemory(F, 2);
1221 case LibFunc::memalign:
1222 if (!FTy->getReturnType()->isPointerTy())
1224 setDoesNotAlias(F, 0);
1226 case LibFunc::mkdir:
1227 if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1230 setDoesNotCapture(F, 1);
1231 setOnlyReadsMemory(F, 1);
1233 case LibFunc::mktime:
1234 if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1237 setDoesNotCapture(F, 1);
1239 case LibFunc::realloc:
1240 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy() ||
1241 !FTy->getReturnType()->isPointerTy())
1244 setDoesNotAlias(F, 0);
1245 setDoesNotCapture(F, 1);
1248 if (FTy->getNumParams() != 3 || !FTy->getParamType(1)->isPointerTy())
1250 // May throw; "read" is a valid pthread cancellation point.
1251 setDoesNotCapture(F, 2);
1253 case LibFunc::rewind:
1254 if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy())
1257 setDoesNotCapture(F, 1);
1259 case LibFunc::rmdir:
1260 case LibFunc::remove:
1261 case LibFunc::realpath:
1262 if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy())
1265 setDoesNotCapture(F, 1);
1266 setOnlyReadsMemory(F, 1);
1268 case LibFunc::rename:
1269 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1270 !FTy->getParamType(1)->isPointerTy())
1273 setDoesNotCapture(F, 1);
1274 setDoesNotCapture(F, 2);
1275 setOnlyReadsMemory(F, 1);
1276 setOnlyReadsMemory(F, 2);
1278 case LibFunc::readlink:
1279 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1280 !FTy->getParamType(1)->isPointerTy())
1283 setDoesNotCapture(F, 1);
1284 setDoesNotCapture(F, 2);
1285 setOnlyReadsMemory(F, 1);
1287 case LibFunc::write:
1288 if (FTy->getNumParams() != 3 || !FTy->getParamType(1)->isPointerTy())
1290 // May throw; "write" is a valid pthread cancellation point.
1291 setDoesNotCapture(F, 2);
1292 setOnlyReadsMemory(F, 2);
1294 case LibFunc::bcopy:
1295 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy() ||
1296 !FTy->getParamType(1)->isPointerTy())
1299 setDoesNotCapture(F, 1);
1300 setDoesNotCapture(F, 2);
1301 setOnlyReadsMemory(F, 1);
1304 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy() ||
1305 !FTy->getParamType(1)->isPointerTy())
1308 setOnlyReadsMemory(F);
1309 setDoesNotCapture(F, 1);
1310 setDoesNotCapture(F, 2);
1312 case LibFunc::bzero:
1313 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy())
1316 setDoesNotCapture(F, 1);
1318 case LibFunc::calloc:
1319 if (FTy->getNumParams() != 2 || !FTy->getReturnType()->isPointerTy())
1322 setDoesNotAlias(F, 0);
1324 case LibFunc::chmod:
1325 case LibFunc::chown:
1326 if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1329 setDoesNotCapture(F, 1);
1330 setOnlyReadsMemory(F, 1);
1332 case LibFunc::ctermid:
1333 case LibFunc::clearerr:
1334 case LibFunc::closedir:
1335 if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1338 setDoesNotCapture(F, 1);
1343 case LibFunc::atoll:
1344 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1347 setOnlyReadsMemory(F);
1348 setDoesNotCapture(F, 1);
1350 case LibFunc::access:
1351 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy())
1354 setDoesNotCapture(F, 1);
1355 setOnlyReadsMemory(F, 1);
1357 case LibFunc::fopen:
1358 if (FTy->getNumParams() != 2 || !FTy->getReturnType()->isPointerTy() ||
1359 !FTy->getParamType(0)->isPointerTy() ||
1360 !FTy->getParamType(1)->isPointerTy())
1363 setDoesNotAlias(F, 0);
1364 setDoesNotCapture(F, 1);
1365 setDoesNotCapture(F, 2);
1366 setOnlyReadsMemory(F, 1);
1367 setOnlyReadsMemory(F, 2);
1369 case LibFunc::fdopen:
1370 if (FTy->getNumParams() != 2 || !FTy->getReturnType()->isPointerTy() ||
1371 !FTy->getParamType(1)->isPointerTy())
1374 setDoesNotAlias(F, 0);
1375 setDoesNotCapture(F, 2);
1376 setOnlyReadsMemory(F, 2);
1380 case LibFunc::fseek:
1381 case LibFunc::ftell:
1382 case LibFunc::fgetc:
1383 case LibFunc::fseeko:
1384 case LibFunc::ftello:
1385 case LibFunc::fileno:
1386 case LibFunc::fflush:
1387 case LibFunc::fclose:
1388 case LibFunc::fsetpos:
1389 case LibFunc::flockfile:
1390 case LibFunc::funlockfile:
1391 case LibFunc::ftrylockfile:
1392 if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1395 setDoesNotCapture(F, 1);
1397 case LibFunc::ferror:
1398 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1401 setDoesNotCapture(F, 1);
1402 setOnlyReadsMemory(F);
1404 case LibFunc::fputc:
1405 case LibFunc::fstat:
1406 case LibFunc::frexp:
1407 case LibFunc::frexpf:
1408 case LibFunc::frexpl:
1409 case LibFunc::fstatvfs:
1410 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1413 setDoesNotCapture(F, 2);
1415 case LibFunc::fgets:
1416 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy() ||
1417 !FTy->getParamType(2)->isPointerTy())
1420 setDoesNotCapture(F, 3);
1422 case LibFunc::fread:
1423 if (FTy->getNumParams() != 4 || !FTy->getParamType(0)->isPointerTy() ||
1424 !FTy->getParamType(3)->isPointerTy())
1427 setDoesNotCapture(F, 1);
1428 setDoesNotCapture(F, 4);
1430 case LibFunc::fwrite:
1431 if (FTy->getNumParams() != 4 || !FTy->getParamType(0)->isPointerTy() ||
1432 !FTy->getParamType(3)->isPointerTy())
1435 setDoesNotCapture(F, 1);
1436 setDoesNotCapture(F, 4);
1438 case LibFunc::fputs:
1439 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1440 !FTy->getParamType(1)->isPointerTy())
1443 setDoesNotCapture(F, 1);
1444 setDoesNotCapture(F, 2);
1445 setOnlyReadsMemory(F, 1);
1447 case LibFunc::fscanf:
1448 case LibFunc::fprintf:
1449 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1450 !FTy->getParamType(1)->isPointerTy())
1453 setDoesNotCapture(F, 1);
1454 setDoesNotCapture(F, 2);
1455 setOnlyReadsMemory(F, 2);
1457 case LibFunc::fgetpos:
1458 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy() ||
1459 !FTy->getParamType(1)->isPointerTy())
1462 setDoesNotCapture(F, 1);
1463 setDoesNotCapture(F, 2);
1466 case LibFunc::getlogin_r:
1467 case LibFunc::getc_unlocked:
1468 if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1471 setDoesNotCapture(F, 1);
1473 case LibFunc::getenv:
1474 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1477 setOnlyReadsMemory(F);
1478 setDoesNotCapture(F, 1);
1481 case LibFunc::getchar:
1484 case LibFunc::getitimer:
1485 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1488 setDoesNotCapture(F, 2);
1490 case LibFunc::getpwnam:
1491 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1494 setDoesNotCapture(F, 1);
1495 setOnlyReadsMemory(F, 1);
1497 case LibFunc::ungetc:
1498 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1501 setDoesNotCapture(F, 2);
1503 case LibFunc::uname:
1504 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1507 setDoesNotCapture(F, 1);
1509 case LibFunc::unlink:
1510 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1513 setDoesNotCapture(F, 1);
1514 setOnlyReadsMemory(F, 1);
1516 case LibFunc::unsetenv:
1517 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1520 setDoesNotCapture(F, 1);
1521 setOnlyReadsMemory(F, 1);
1523 case LibFunc::utime:
1524 case LibFunc::utimes:
1525 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy() ||
1526 !FTy->getParamType(1)->isPointerTy())
1529 setDoesNotCapture(F, 1);
1530 setDoesNotCapture(F, 2);
1531 setOnlyReadsMemory(F, 1);
1532 setOnlyReadsMemory(F, 2);
1535 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1538 setDoesNotCapture(F, 2);
1541 case LibFunc::printf:
1542 case LibFunc::perror:
1543 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1546 setDoesNotCapture(F, 1);
1547 setOnlyReadsMemory(F, 1);
1549 case LibFunc::pread:
1550 if (FTy->getNumParams() != 4 || !FTy->getParamType(1)->isPointerTy())
1552 // May throw; "pread" is a valid pthread cancellation point.
1553 setDoesNotCapture(F, 2);
1555 case LibFunc::pwrite:
1556 if (FTy->getNumParams() != 4 || !FTy->getParamType(1)->isPointerTy())
1558 // May throw; "pwrite" is a valid pthread cancellation point.
1559 setDoesNotCapture(F, 2);
1560 setOnlyReadsMemory(F, 2);
1562 case LibFunc::putchar:
1565 case LibFunc::popen:
1566 if (FTy->getNumParams() != 2 || !FTy->getReturnType()->isPointerTy() ||
1567 !FTy->getParamType(0)->isPointerTy() ||
1568 !FTy->getParamType(1)->isPointerTy())
1571 setDoesNotAlias(F, 0);
1572 setDoesNotCapture(F, 1);
1573 setDoesNotCapture(F, 2);
1574 setOnlyReadsMemory(F, 1);
1575 setOnlyReadsMemory(F, 2);
1577 case LibFunc::pclose:
1578 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1581 setDoesNotCapture(F, 1);
1583 case LibFunc::vscanf:
1584 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1587 setDoesNotCapture(F, 1);
1588 setOnlyReadsMemory(F, 1);
1590 case LibFunc::vsscanf:
1591 if (FTy->getNumParams() != 3 || !FTy->getParamType(1)->isPointerTy() ||
1592 !FTy->getParamType(2)->isPointerTy())
1595 setDoesNotCapture(F, 1);
1596 setDoesNotCapture(F, 2);
1597 setOnlyReadsMemory(F, 1);
1598 setOnlyReadsMemory(F, 2);
1600 case LibFunc::vfscanf:
1601 if (FTy->getNumParams() != 3 || !FTy->getParamType(1)->isPointerTy() ||
1602 !FTy->getParamType(2)->isPointerTy())
1605 setDoesNotCapture(F, 1);
1606 setDoesNotCapture(F, 2);
1607 setOnlyReadsMemory(F, 2);
1609 case LibFunc::valloc:
1610 if (!FTy->getReturnType()->isPointerTy())
1613 setDoesNotAlias(F, 0);
1615 case LibFunc::vprintf:
1616 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy())
1619 setDoesNotCapture(F, 1);
1620 setOnlyReadsMemory(F, 1);
1622 case LibFunc::vfprintf:
1623 case LibFunc::vsprintf:
1624 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy() ||
1625 !FTy->getParamType(1)->isPointerTy())
1628 setDoesNotCapture(F, 1);
1629 setDoesNotCapture(F, 2);
1630 setOnlyReadsMemory(F, 2);
1632 case LibFunc::vsnprintf:
1633 if (FTy->getNumParams() != 4 || !FTy->getParamType(0)->isPointerTy() ||
1634 !FTy->getParamType(2)->isPointerTy())
1637 setDoesNotCapture(F, 1);
1638 setDoesNotCapture(F, 3);
1639 setOnlyReadsMemory(F, 3);
1642 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy())
1644 // May throw; "open" is a valid pthread cancellation point.
1645 setDoesNotCapture(F, 1);
1646 setOnlyReadsMemory(F, 1);
1648 case LibFunc::opendir:
1649 if (FTy->getNumParams() != 1 || !FTy->getReturnType()->isPointerTy() ||
1650 !FTy->getParamType(0)->isPointerTy())
1653 setDoesNotAlias(F, 0);
1654 setDoesNotCapture(F, 1);
1655 setOnlyReadsMemory(F, 1);
1657 case LibFunc::tmpfile:
1658 if (!FTy->getReturnType()->isPointerTy())
1661 setDoesNotAlias(F, 0);
1663 case LibFunc::times:
1664 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1667 setDoesNotCapture(F, 1);
1669 case LibFunc::htonl:
1670 case LibFunc::htons:
1671 case LibFunc::ntohl:
1672 case LibFunc::ntohs:
1674 setDoesNotAccessMemory(F);
1676 case LibFunc::lstat:
1677 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy() ||
1678 !FTy->getParamType(1)->isPointerTy())
1681 setDoesNotCapture(F, 1);
1682 setDoesNotCapture(F, 2);
1683 setOnlyReadsMemory(F, 1);
1685 case LibFunc::lchown:
1686 if (FTy->getNumParams() != 3 || !FTy->getParamType(0)->isPointerTy())
1689 setDoesNotCapture(F, 1);
1690 setOnlyReadsMemory(F, 1);
1692 case LibFunc::qsort:
1693 if (FTy->getNumParams() != 4 || !FTy->getParamType(3)->isPointerTy())
1695 // May throw; places call through function pointer.
1696 setDoesNotCapture(F, 4);
1698 case LibFunc::dunder_strdup:
1699 case LibFunc::dunder_strndup:
1700 if (FTy->getNumParams() < 1 || !FTy->getReturnType()->isPointerTy() ||
1701 !FTy->getParamType(0)->isPointerTy())
1704 setDoesNotAlias(F, 0);
1705 setDoesNotCapture(F, 1);
1706 setOnlyReadsMemory(F, 1);
1708 case LibFunc::dunder_strtok_r:
1709 if (FTy->getNumParams() != 3 || !FTy->getParamType(1)->isPointerTy())
1712 setDoesNotCapture(F, 2);
1713 setOnlyReadsMemory(F, 2);
1715 case LibFunc::under_IO_getc:
1716 if (FTy->getNumParams() != 1 || !FTy->getParamType(0)->isPointerTy())
1719 setDoesNotCapture(F, 1);
1721 case LibFunc::under_IO_putc:
1722 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1725 setDoesNotCapture(F, 2);
1727 case LibFunc::dunder_isoc99_scanf:
1728 if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy())
1731 setDoesNotCapture(F, 1);
1732 setOnlyReadsMemory(F, 1);
1734 case LibFunc::stat64:
1735 case LibFunc::lstat64:
1736 case LibFunc::statvfs64:
1737 if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy() ||
1738 !FTy->getParamType(1)->isPointerTy())
1741 setDoesNotCapture(F, 1);
1742 setDoesNotCapture(F, 2);
1743 setOnlyReadsMemory(F, 1);
1745 case LibFunc::dunder_isoc99_sscanf:
1746 if (FTy->getNumParams() < 1 || !FTy->getParamType(0)->isPointerTy() ||
1747 !FTy->getParamType(1)->isPointerTy())
1750 setDoesNotCapture(F, 1);
1751 setDoesNotCapture(F, 2);
1752 setOnlyReadsMemory(F, 1);
1753 setOnlyReadsMemory(F, 2);
1755 case LibFunc::fopen64:
1756 if (FTy->getNumParams() != 2 || !FTy->getReturnType()->isPointerTy() ||
1757 !FTy->getParamType(0)->isPointerTy() ||
1758 !FTy->getParamType(1)->isPointerTy())
1761 setDoesNotAlias(F, 0);
1762 setDoesNotCapture(F, 1);
1763 setDoesNotCapture(F, 2);
1764 setOnlyReadsMemory(F, 1);
1765 setOnlyReadsMemory(F, 2);
1767 case LibFunc::fseeko64:
1768 case LibFunc::ftello64:
1769 if (FTy->getNumParams() == 0 || !FTy->getParamType(0)->isPointerTy())
1772 setDoesNotCapture(F, 1);
1774 case LibFunc::tmpfile64:
1775 if (!FTy->getReturnType()->isPointerTy())
1778 setDoesNotAlias(F, 0);
1780 case LibFunc::fstat64:
1781 case LibFunc::fstatvfs64:
1782 if (FTy->getNumParams() != 2 || !FTy->getParamType(1)->isPointerTy())
1785 setDoesNotCapture(F, 2);
1787 case LibFunc::open64:
1788 if (FTy->getNumParams() < 2 || !FTy->getParamType(0)->isPointerTy())
1790 // May throw; "open" is a valid pthread cancellation point.
1791 setDoesNotCapture(F, 1);
1792 setOnlyReadsMemory(F, 1);
1794 case LibFunc::gettimeofday:
1795 if (FTy->getNumParams() != 2 || !FTy->getParamType(0)->isPointerTy() ||
1796 !FTy->getParamType(1)->isPointerTy())
1798 // Currently some platforms have the restrict keyword on the arguments to
1799 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
1802 setDoesNotCapture(F, 1);
1803 setDoesNotCapture(F, 2);
1806 // Didn't mark any attributes.
1813 /// Adds attributes to well-known standard library call declarations.
1814 bool FunctionAttrs::annotateLibraryCalls(const CallGraphSCC &SCC) {
1815 bool MadeChange = false;
1817 // Check each function in turn annotating well-known library function
1818 // declarations with attributes.
1819 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
1820 Function *F = (*I)->getFunction();
1822 if (F && F->isDeclaration())
1823 MadeChange |= inferPrototypeAttributes(*F, *TLI);
1829 bool FunctionAttrs::runOnSCC(CallGraphSCC &SCC) {
1830 TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
1832 bool Changed = annotateLibraryCalls(SCC);
1833 Changed |= AddReadAttrs(SCC);
1834 Changed |= AddArgumentAttrs(SCC);
1835 Changed |= AddNoAliasAttrs(SCC);
1836 Changed |= AddNonNullAttrs(SCC);