Members/tobaru/cbc/CbC_llvm: lib/Transforms/IPO/FunctionAttrs.cpp comparison

comparison lib/Transforms/IPO/FunctionAttrs.cpp @ 77:54457678186b

LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Mon, 08 Sep 2014 22:06:00 +0900
parents	e4204d083e25
children	60c9769439b8

comparison

equal deleted inserted replaced

-:e874dbf0ad9d
+:54457678186b
 // function's standard definition. This pass is implemented as a
 // bottom-up traversal of the call-graph.
 //
 //===----------------------------------------------------------------------===//
-#define DEBUG_TYPE "functionattrs"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/InstIterator.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
-#include "llvm/Support/InstIterator.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 using namespace llvm;
+#define DEBUG_TYPE "functionattrs"
 STATISTIC(NumReadNone, "Number of functions marked readnone");
 STATISTIC(NumReadOnly, "Number of functions marked readonly");
 STATISTIC(NumNoCapture, "Number of arguments marked nocapture");
 STATISTIC(NumReadNoneArg, "Number of arguments marked readnone");
 STATISTIC(NumAnnotated, "Number of attributes added to library functions");
 namespace {
 struct FunctionAttrs : public CallGraphSCCPass {
 static char ID; // Pass identification, replacement for typeid
-FunctionAttrs() : CallGraphSCCPass(ID), AA(0) {
+FunctionAttrs() : CallGraphSCCPass(ID), AA(nullptr) {
 initializeFunctionAttrsPass(*PassRegistry::getPassRegistry());
 }
 // runOnSCC - Analyze the SCC, performing the transformation if possible.
-bool runOnSCC(CallGraphSCC &SCC);
+bool runOnSCC(CallGraphSCC &SCC) override;
 // AddReadAttrs - Deduce readonly/readnone attributes for the SCC.
 bool AddReadAttrs(const CallGraphSCC &SCC);
 // AddArgumentAttrs - Deduce nocapture attributes for the SCC.
 // annotateLibraryCalls - Adds attributes to well-known standard library
 // call declarations.
 bool annotateLibraryCalls(const CallGraphSCC &SCC);
-virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+void getAnalysisUsage(AnalysisUsage &AU) const override {
 AU.setPreservesCFG();
 AU.addRequired<AliasAnalysis>();
 AU.addRequired<TargetLibraryInfo>();
 CallGraphSCCPass::getAnalysisUsage(AU);
 }
 // write memory then they can't be marked readnone or readonly.
 bool ReadsMemory = false;
 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
 Function *F = (*I)->getFunction();
-if (F == 0)
+if (!F || F->hasFnAttribute(Attribute::OptimizeNone))
-// External node - may write memory.  Just give up.
+// External node or node we don't want to optimize - assume it may write
+// memory and give up.
 return false;
 AliasAnalysis::ModRefBehavior MRB = AA->getModRefBehavior(F);
 if (MRB == AliasAnalysis::DoesNotAccessMemory)
 // Already perfect!
 // ignore calls that only access local memory.
 for (CallSite::arg_iterator CI = CS.arg_begin(), CE = CS.arg_end();
 CI != CE; ++CI) {
 Value *Arg = *CI;
 if (Arg->getType()->isPointerTy()) {
+AAMDNodes AAInfo;
+I->getAAMetadata(AAInfo);
 AliasAnalysis::Location Loc(Arg,
-AliasAnalysis::UnknownSize,
+AliasAnalysis::UnknownSize, AAInfo);
-I->getMetadata(LLVMContext::MD_tbaa));
 if (!AA->pointsToConstantMemory(Loc, /*OrLocal=*/true)) {
 if (MRB & AliasAnalysis::Mod)
 // Writes non-local memory.  Give up.
 return false;
 if (MRB & AliasAnalysis::Ref)
 // uses every node. Because the graph is directed and nothing points into
 // the root, it will not participate in any SCCs (except for its own).
 ArgumentGraphNode SyntheticRoot;
 public:
-ArgumentGraph() { SyntheticRoot.Definition = 0; }
+ArgumentGraph() { SyntheticRoot.Definition = nullptr; }
 typedef SmallVectorImpl<ArgumentGraphNode*>::iterator iterator;
 iterator begin() { return SyntheticRoot.Uses.begin(); }
 iterator end() { return SyntheticRoot.Uses.end(); }
 // continuing with the analysis.
 struct ArgumentUsesTracker : public CaptureTracker {
 ArgumentUsesTracker(const SmallPtrSet<Function*, 8> &SCCNodes)
 : Captured(false), SCCNodes(SCCNodes) {}
-void tooManyUses() { Captured = true; }
+void tooManyUses() override { Captured = true; }
-bool captured(Use *U) {
+bool captured(const Use *U) override {
 CallSite CS(U->getUser());
 if (!CS.getInstruction()) { Captured = true; return true; }
 Function *F = CS.getCalledFunction();
 if (!F || !SCCNodes.count(F)) { Captured = true; return true; }
 SmallVector<Use*, 32> Worklist;
 SmallSet<Use*, 32> Visited;
 int Count = 0;
+// inalloca arguments are always clobbered by the call.
+if (A->hasInAllocaAttr())
+return Attribute::None;
 bool IsRead = false;
 // We don't need to track IsWritten. If A is written to, return immediately.
-for (Value::use_iterator UI = A->use_begin(), UE = A->use_end();
+for (Use &U : A->uses()) {
-UI != UE; ++UI) {
 if (Count++ >= 20)
 return Attribute::None;
-Use *U = &UI.getUse();
+Visited.insert(&U);
-Visited.insert(U);
+Worklist.push_back(&U);
-Worklist.push_back(U);
 }
 while (!Worklist.empty()) {
 Use *U = Worklist.pop_back_val();
 Instruction *I = cast<Instruction>(U->getUser());
 switch (I->getOpcode()) {
 case Instruction::BitCast:
 case Instruction::GetElementPtr:
 case Instruction::PHI:
 case Instruction::Select:
+case Instruction::AddrSpaceCast:
 // The original value is not read/written via this if the new value isn't.
-for (Instruction::use_iterator UI = I->use_begin(), UE = I->use_end();
+for (Use &UU : I->uses())
-UI != UE; ++UI) {
+if (Visited.insert(&UU))
-Use *U = &UI.getUse();
+Worklist.push_back(&UU);
-if (Visited.insert(U))
-Worklist.push_back(U);
-}
 break;
 case Instruction::Call:
 case Instruction::Invoke: {
+bool Captures = true;
+if (I->getType()->isVoidTy())
+Captures = false;
+auto AddUsersToWorklistIfCapturing = [&] {
+if (Captures)
+for (Use &UU : I->uses())
+if (Visited.insert(&UU))
+Worklist.push_back(&UU);
+};
 CallSite CS(I);
-if (CS.doesNotAccessMemory())
+if (CS.doesNotAccessMemory()) {
+AddUsersToWorklistIfCapturing();
 continue;
+}
 Function *F = CS.getCalledFunction();
 if (!F) {
 if (CS.onlyReadsMemory()) {
 IsRead = true;
+AddUsersToWorklistIfCapturing();
 continue;
 }
 return Attribute::None;
 }
 if (AI == AE) {
 assert(F->isVarArg() &&
 "More params than args in non-varargs call.");
 return Attribute::None;
 }
+Captures &= !CS.doesNotCapture(A - B);
 if (SCCNodes.count(AI))
 continue;
 if (!CS.onlyReadsMemory() && !CS.onlyReadsMemory(A - B))
 return Attribute::None;
 if (!CS.doesNotAccessMemory(A - B))
 IsRead = true;
 }
 }
+AddUsersToWorklistIfCapturing();
 break;
 }
 case Instruction::Load:
 IsRead = true;
 // Fill SCCNodes with the elements of the SCC.  Used for quickly
 // looking up whether a given CallGraphNode is in this SCC.
 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
 Function *F = (*I)->getFunction();
-if (F && !F->isDeclaration() && !F->mayBeOverridden())
+if (F && !F->isDeclaration() && !F->mayBeOverridden() &&
+!F->hasFnAttribute(Attribute::OptimizeNone))
 SCCNodes.insert(F);
 }
 ArgumentGraph AG;
 // Check each function in turn, determining which pointer arguments are not
 // captured.
 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
 Function *F = (*I)->getFunction();
-if (F == 0)
+if (!F || F->hasFnAttribute(Attribute::OptimizeNone))
-// External node - only a problem for arguments that we pass to it.
+// External node or function we're trying not to optimize - only a problem
+// for arguments that we pass to it.
 continue;
 // Definitions with weak linkage may be overridden at linktime with
 // something that captures pointers, so treat them like declarations.
 if (F->isDeclaration() || F->mayBeOverridden())
 // show up as ArgumentGraphNode objects with an empty Uses list, and for
 // these nodes the final decision about whether they capture has already been
 // made.  If the definition doesn't have a 'nocapture' attribute by now, it
 // captures.
-for (scc_iterator<ArgumentGraph*> I = scc_begin(&AG), E = scc_end(&AG);
+for (scc_iterator<ArgumentGraph*> I = scc_begin(&AG); !I.isAtEnd(); ++I) {
-I != E; ++I) {
+const std::vector<ArgumentGraphNode *> &ArgumentSCC = *I;
-std::vector<ArgumentGraphNode*> &ArgumentSCC = *I;
 if (ArgumentSCC.size() == 1) {
 if (!ArgumentSCC[0]->Definition) continue;  // synthetic root node
 // eg. "void f(int* x) { if (...) f(x); }"
 if (ArgumentSCC[0]->Uses.size() == 1 &&
 }
 continue;
 }
 bool SCCCaptured = false;
-for (std::vector<ArgumentGraphNode*>::iterator I = ArgumentSCC.begin(),
+for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end();
-E = ArgumentSCC.end(); I != E && !SCCCaptured; ++I) {
+I != E && !SCCCaptured; ++I) {
 ArgumentGraphNode *Node = *I;
 if (Node->Uses.empty()) {
 if (!Node->Definition->hasNoCaptureAttr())
 SCCCaptured = true;
 }
 if (SCCCaptured) continue;
 SmallPtrSet<Argument*, 8> ArgumentSCCNodes;
 // Fill ArgumentSCCNodes with the elements of the ArgumentSCC.  Used for
 // quickly looking up whether a given Argument is in this ArgumentSCC.
-for (std::vector<ArgumentGraphNode*>::iterator I = ArgumentSCC.begin(),
+for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end(); I != E; ++I) {
-E = ArgumentSCC.end(); I != E; ++I) {
 ArgumentSCCNodes.insert((*I)->Definition);
 }
-for (std::vector<ArgumentGraphNode*>::iterator I = ArgumentSCC.begin(),
+for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end();
-E = ArgumentSCC.end(); I != E && !SCCCaptured; ++I) {
+I != E && !SCCCaptured; ++I) {
 ArgumentGraphNode *N = *I;
 for (SmallVectorImpl<ArgumentGraphNode*>::iterator UI = N->Uses.begin(),
 UE = N->Uses.end(); UI != UE; ++UI) {
 Argument *A = (*UI)->Definition;
 if (A->hasNoCaptureAttr() || ArgumentSCCNodes.count(A))
 if (Instruction *RVI = dyn_cast<Instruction>(RetVal))
 switch (RVI->getOpcode()) {
 // Extend the analysis by looking upwards.
 case Instruction::BitCast:
 case Instruction::GetElementPtr:
+case Instruction::AddrSpaceCast:
 FlowsToReturn.insert(RVI->getOperand(0));
 continue;
 case Instruction::Select: {
 SelectInst *SI = cast<SelectInst>(RVI);
 FlowsToReturn.insert(SI->getTrueValue());
 // Check each function in turn, determining which functions return noalias
 // pointers.
 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
 Function *F = (*I)->getFunction();
-if (F == 0)
+if (!F || F->hasFnAttribute(Attribute::OptimizeNone))
-// External node - skip it;
+// External node or node we don't want to optimize - skip it;
 return false;
 // Already noalias.
 if (F->doesNotAlias(0))
 continue;
 /// inferPrototypeAttributes - Analyze the name and prototype of the
 /// given function and set any applicable attributes.  Returns true
 /// if any attributes were set and false otherwise.
 bool FunctionAttrs::inferPrototypeAttributes(Function &F) {
+if (F.hasFnAttribute(Attribute::OptimizeNone))
+return false;
 FunctionType *FTy = F.getFunctionType();
 LibFunc::Func TheLibFunc;
 if (!(TLI->getLibFunc(F.getName(), TheLibFunc) && TLI->has(TheLibFunc)))
 return false;
 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
 // arguments.
 setDoesNotThrow(F);
 setDoesNotCapture(F, 1);
 setDoesNotCapture(F, 2);
+break;
 default:
 // Didn't mark any attributes.
 return false;
 }
 // Check each function in turn annotating well-known library function
 // declarations with attributes.
 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
 Function *F = (*I)->getFunction();
-if (F != 0 && F->isDeclaration())
+if (F && F->isDeclaration())
 MadeChange |= inferPrototypeAttributes(*F);
 }
 return MadeChange;
 }

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/Transforms/IPO/FunctionAttrs.cpp @ 77:54457678186b