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/GlobalVariable.h"
21 #include "llvm/Instructions.h"
22 #include "llvm/Analysis/CallGraph.h"
23 #include "llvm/ADT/SmallPtrSet.h"
24 #include "llvm/ADT/Statistic.h"
25 #include "llvm/Support/Compiler.h"
26 #include "llvm/Support/InstIterator.h"
29 STATISTIC(NumReadNone, "Number of functions marked readnone");
30 STATISTIC(NumReadOnly, "Number of functions marked readonly");
33 struct VISIBILITY_HIDDEN AddReadAttrs : public CallGraphSCCPass {
34 static char ID; // Pass identification, replacement for typeid
35 AddReadAttrs() : CallGraphSCCPass(&ID) {}
37 // runOnSCC - Analyze the SCC, performing the transformation if possible.
38 bool runOnSCC(const std::vector<CallGraphNode *> &SCC);
40 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
42 CallGraphSCCPass::getAnalysisUsage(AU);
45 bool PointsToLocalMemory(Value *V);
49 char AddReadAttrs::ID = 0;
50 static RegisterPass<AddReadAttrs>
51 X("addreadattrs", "Mark functions readnone/readonly");
53 Pass *llvm::createAddReadAttrsPass() { return new AddReadAttrs(); }
56 /// PointsToLocalMemory - Returns whether the given pointer value points to
57 /// memory that is local to the function. Global constants are considered
58 /// local to all functions.
59 bool AddReadAttrs::PointsToLocalMemory(Value *V) {
60 V = V->getUnderlyingObject();
61 // An alloca instruction defines local memory.
62 if (isa<AllocaInst>(V))
64 // A global constant counts as local memory for our purposes.
65 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
66 return GV->isConstant();
67 // Could look through phi nodes and selects here, but it doesn't seem
68 // to be useful in practice.
72 bool AddReadAttrs::runOnSCC(const std::vector<CallGraphNode *> &SCC) {
73 SmallPtrSet<CallGraphNode *, 8> SCCNodes;
74 CallGraph &CG = getAnalysis<CallGraph>();
76 // Fill SCCNodes with the elements of the SCC. Used for quickly
77 // looking up whether a given CallGraphNode is in this SCC.
78 for (unsigned i = 0, e = SCC.size(); i != e; ++i)
79 SCCNodes.insert(SCC[i]);
81 // Check if any of the functions in the SCC read or write memory. If they
82 // write memory then they can't be marked readnone or readonly.
83 bool ReadsMemory = false;
84 for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
85 Function *F = SCC[i]->getFunction();
88 // External node - may write memory. Just give up.
91 if (F->doesNotAccessMemory())
95 // Definitions with weak linkage may be overridden at linktime with
96 // something that writes memory, so treat them like declarations.
97 if (F->isDeclaration() || F->mayBeOverridden()) {
98 if (!F->onlyReadsMemory())
99 // May write memory. Just give up.
106 // Scan the function body for instructions that may read or write memory.
107 for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) {
108 Instruction *I = &*II;
110 // Some instructions can be ignored even if they read or write memory.
111 // Detect these now, skipping to the next instruction if one is found.
112 CallSite CS = CallSite::get(I);
113 if (CS.getInstruction()) {
114 // Ignore calls to functions in the same SCC.
115 if (SCCNodes.count(CG[CS.getCalledFunction()]))
117 } else if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
118 // Ignore loads from local memory.
119 if (PointsToLocalMemory(LI->getPointerOperand()))
121 } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
122 // Ignore stores to local memory.
123 if (PointsToLocalMemory(SI->getPointerOperand()))
127 // Any remaining instructions need to be taken seriously! Check if they
128 // read or write memory.
129 if (I->mayWriteToMemory())
130 // Writes memory. Just give up.
132 // If this instruction may read memory, remember that.
133 ReadsMemory |= I->mayReadFromMemory();
137 // Success! Functions in this SCC do not access memory, or only read memory.
138 // Give them the appropriate attribute.
139 bool MadeChange = false;
140 for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
141 Function *F = SCC[i]->getFunction();
143 if (F->doesNotAccessMemory())
147 if (F->onlyReadsMemory() && ReadsMemory)
153 // Clear out any existing attributes.
154 F->removeAttribute(~0, Attribute::ReadOnly | Attribute::ReadNone);
156 // Add in the new attribute.
157 F->addAttribute(~0, ReadsMemory ? Attribute::ReadOnly : Attribute::ReadNone);