#define DEBUG_TYPE "functionattrs"
#include "llvm/Transforms/IPO.h"
#include "llvm/CallGraphSCCPass.h"
#include "llvm/GlobalVariable.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/Analysis/CaptureTracking.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/UniqueVector.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/InstIterator.h"
using namespace llvm;
STATISTIC(NumReadNone, "Number of functions marked readnone");
STATISTIC(NumReadOnly, "Number of functions marked readonly");
STATISTIC(NumNoCapture, "Number of arguments marked nocapture");
STATISTIC(NumNoAlias, "Number of function returns marked noalias");
namespace {
struct VISIBILITY_HIDDEN FunctionAttrs : public CallGraphSCCPass {
static char ID; FunctionAttrs() : CallGraphSCCPass(&ID) {}
bool runOnSCC(const std::vector<CallGraphNode *> &SCC);
bool AddReadAttrs(const std::vector<CallGraphNode *> &SCC);
bool AddNoCaptureAttrs(const std::vector<CallGraphNode *> &SCC);
bool IsFunctionMallocLike(Function *F,
SmallPtrSet<CallGraphNode*, 8> &) const;
bool AddNoAliasAttrs(const std::vector<CallGraphNode *> &SCC);
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesCFG();
CallGraphSCCPass::getAnalysisUsage(AU);
}
bool PointsToLocalMemory(Value *V);
};
}
char FunctionAttrs::ID = 0;
static RegisterPass<FunctionAttrs>
X("functionattrs", "Deduce function attributes");
Pass *llvm::createFunctionAttrsPass() { return new FunctionAttrs(); }
bool FunctionAttrs::PointsToLocalMemory(Value *V) {
V = V->getUnderlyingObject();
if (isa<AllocaInst>(V))
return true;
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
return GV->isConstant();
return false;
}
bool FunctionAttrs::AddReadAttrs(const std::vector<CallGraphNode *> &SCC) {
SmallPtrSet<CallGraphNode*, 8> SCCNodes;
CallGraph &CG = getAnalysis<CallGraph>();
for (unsigned i = 0, e = SCC.size(); i != e; ++i)
SCCNodes.insert(SCC[i]);
bool ReadsMemory = false;
for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
Function *F = SCC[i]->getFunction();
if (F == 0)
return false;
if (F->doesNotAccessMemory())
continue;
if (F->isDeclaration() || F->mayBeOverridden()) {
if (!F->onlyReadsMemory())
return false;
ReadsMemory = true;
continue;
}
for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) {
Instruction *I = &*II;
CallSite CS = CallSite::get(I);
if (CS.getInstruction()) {
if (SCCNodes.count(CG[CS.getCalledFunction()]))
continue;
} else if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
if (PointsToLocalMemory(LI->getPointerOperand()))
continue;
} else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
if (PointsToLocalMemory(SI->getPointerOperand()))
continue;
}
if (I->mayWriteToMemory())
return false;
ReadsMemory |= I->mayReadFromMemory();
}
}
bool MadeChange = false;
for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
Function *F = SCC[i]->getFunction();
if (F->doesNotAccessMemory())
continue;
if (F->onlyReadsMemory() && ReadsMemory)
continue;
MadeChange = true;
F->removeAttribute(~0, Attribute::ReadOnly | Attribute::ReadNone);
F->addAttribute(~0, ReadsMemory? Attribute::ReadOnly : Attribute::ReadNone);
if (ReadsMemory)
++NumReadOnly;
else
++NumReadNone;
}
return MadeChange;
}
bool FunctionAttrs::AddNoCaptureAttrs(const std::vector<CallGraphNode *> &SCC) {
bool Changed = false;
for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
Function *F = SCC[i]->getFunction();
if (F == 0)
continue;
if (F->isDeclaration() || F->mayBeOverridden())
continue;
for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A!=E; ++A)
if (isa<PointerType>(A->getType()) && !A->hasNoCaptureAttr() &&
!PointerMayBeCaptured(A, true)) {
A->addAttr(Attribute::NoCapture);
++NumNoCapture;
Changed = true;
}
}
return Changed;
}
bool FunctionAttrs::IsFunctionMallocLike(Function *F,
SmallPtrSet<CallGraphNode*, 8> &SCCNodes) const {
CallGraph &CG = getAnalysis<CallGraph>();
UniqueVector<Value *> FlowsToReturn;
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I)
if (ReturnInst *Ret = dyn_cast<ReturnInst>(I->getTerminator()))
FlowsToReturn.insert(Ret->getReturnValue());
for (unsigned i = 0; i != FlowsToReturn.size(); ++i) {
Value *RetVal = FlowsToReturn[i+1];
if (Constant *C = dyn_cast<Constant>(RetVal)) {
if (!C->isNullValue() && !isa<UndefValue>(C))
return false;
continue;
}
if (isa<Argument>(RetVal))
return false;
if (Instruction *RVI = dyn_cast<Instruction>(RetVal))
switch (RVI->getOpcode()) {
case Instruction::GetElementPtr:
case Instruction::BitCast:
FlowsToReturn.insert(RVI->getOperand(0));
continue;
case Instruction::Select: {
SelectInst *SI = cast<SelectInst>(RVI);
FlowsToReturn.insert(SI->getTrueValue());
FlowsToReturn.insert(SI->getFalseValue());
} continue;
case Instruction::PHI: {
PHINode *PN = cast<PHINode>(RVI);
for (int i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
FlowsToReturn.insert(PN->getIncomingValue(i));
} continue;
case Instruction::Alloca:
case Instruction::Malloc:
break;
case Instruction::Call:
case Instruction::Invoke: {
CallSite CS(RVI);
if (CS.paramHasAttr(0, Attribute::NoAlias))
break;
if (CS.getCalledFunction() &&
SCCNodes.count(CG[CS.getCalledFunction()]))
break;
} default:
return false; }
if (PointerMayBeCaptured(RetVal, false))
return false;
}
return true;
}
bool FunctionAttrs::AddNoAliasAttrs(const std::vector<CallGraphNode *> &SCC) {
SmallPtrSet<CallGraphNode*, 8> SCCNodes;
for (unsigned i = 0, e = SCC.size(); i != e; ++i)
SCCNodes.insert(SCC[i]);
for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
Function *F = SCC[i]->getFunction();
if (F == 0)
return false;
if (F->doesNotAlias(0))
continue;
if (F->isDeclaration() || F->mayBeOverridden())
return false;
if (!isa<PointerType>(F->getReturnType()))
continue;
if (!IsFunctionMallocLike(F, SCCNodes))
return false;
}
bool MadeChange = false;
for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
Function *F = SCC[i]->getFunction();
if (F->doesNotAlias(0) || !isa<PointerType>(F->getReturnType()))
continue;
F->setDoesNotAlias(0);
++NumNoAlias;
MadeChange = true;
}
return MadeChange;
}
bool FunctionAttrs::runOnSCC(const std::vector<CallGraphNode *> &SCC) {
bool Changed = AddReadAttrs(SCC);
Changed |= AddNoCaptureAttrs(SCC);
Changed |= AddNoAliasAttrs(SCC);
return Changed;
}