1 //===- AddReadAttrs.cpp - Pass which marks functions readnone or readonly -===//
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 implements
13 // this as a bottom-up traversal of the call-graph.
15 //===----------------------------------------------------------------------===//
17 #define DEBUG_TYPE "addreadattrs"
18 #include "llvm/Transforms/IPO.h"
19 #include "llvm/CallGraphSCCPass.h"
20 #include "llvm/Instructions.h"
21 #include "llvm/Analysis/CallGraph.h"
22 #include "llvm/ADT/SmallPtrSet.h"
23 #include "llvm/ADT/Statistic.h"
24 #include "llvm/Support/Compiler.h"
25 #include "llvm/Support/InstIterator.h"
28 STATISTIC(NumReadNone, "Number of functions marked readnone");
29 STATISTIC(NumReadOnly, "Number of functions marked readonly");
32 struct VISIBILITY_HIDDEN AddReadAttrs : public CallGraphSCCPass {
33 static char ID; // Pass identification, replacement for typeid
34 AddReadAttrs() : CallGraphSCCPass(&ID) {}
36 // runOnSCC - Analyze the SCC, performing the transformation if possible.
37 bool runOnSCC(const std::vector<CallGraphNode *> &SCC);
39 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
41 CallGraphSCCPass::getAnalysisUsage(AU);
46 char AddReadAttrs::ID = 0;
47 static RegisterPass<AddReadAttrs>
48 X("addreadattrs", "Mark functions readnone/readonly");
50 Pass *llvm::createAddReadAttrsPass() { return new AddReadAttrs(); }
53 bool AddReadAttrs::runOnSCC(const std::vector<CallGraphNode *> &SCC) {
54 SmallPtrSet<CallGraphNode *, 8> SCCNodes;
55 CallGraph &CG = getAnalysis<CallGraph>();
57 // Fill SCCNodes with the elements of the SCC. Used for quickly
58 // looking up whether a given CallGraphNode is in this SCC.
59 for (unsigned i = 0, e = SCC.size(); i != e; ++i)
60 SCCNodes.insert(SCC[i]);
62 // Check if any of the functions in the SCC read or write memory. If they
63 // write memory then they can't be marked readnone or readonly.
64 bool ReadsMemory = false;
65 for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
66 Function *F = SCC[i]->getFunction();
69 // External node - may write memory. Just give up.
72 if (F->doesNotAccessMemory())
76 // Definitions with weak linkage may be overridden at linktime with
77 // something that writes memory, so treat them like declarations.
78 if (F->isDeclaration() || F->mayBeOverridden()) {
79 if (!F->onlyReadsMemory())
80 // May write memory. Just give up.
87 // Scan the function body for instructions that may read or write memory.
88 for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) {
89 Instruction *I = &*II;
91 // Some instructions can be ignored even if they read or write memory.
92 // Detect these now, skipping to the next instruction if one is found.
93 CallSite CS = CallSite::get(I);
94 if (CS.getInstruction()) {
95 // Ignore calls to functions in the same SCC.
96 if (SCCNodes.count(CG[CS.getCalledFunction()]))
98 } else if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
99 Value *Target = LI->getPointerOperand()->getUnderlyingObject();
100 // Ignore loads from local memory.
101 if (isa<AllocaInst>(Target))
103 } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
104 Value *Target = SI->getPointerOperand()->getUnderlyingObject();
105 // Ignore stores to local memory.
106 if (isa<AllocaInst>(Target))
110 // Any remaining instructions need to be taken seriously! Check if they
111 // read or write memory.
112 if (I->mayWriteToMemory())
113 // Writes memory. Just give up.
115 // If this instruction may read memory, remember that.
116 ReadsMemory |= I->mayReadFromMemory();
120 // Success! Functions in this SCC do not access memory, or only read memory.
121 // Give them the appropriate attribute.
122 bool MadeChange = false;
123 for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
124 Function *F = SCC[i]->getFunction();
126 if (F->doesNotAccessMemory())
130 if (F->onlyReadsMemory() && ReadsMemory)
136 // Clear out any existing attributes.
137 F->removeAttribute(~0, Attribute::ReadOnly | Attribute::ReadNone);
139 // Add in the new attribute.
140 F->addAttribute(~0, ReadsMemory ? Attribute::ReadOnly : Attribute::ReadNone);