From 672ef54d0f10fbb6363af509c62ab98c1bfa7f50 Mon Sep 17 00:00:00 2001 From: Dale Johannesen Date: Thu, 19 Mar 2009 18:03:56 +0000 Subject: [PATCH] Clear the cached cost when removing a function in the inliner; prevents nondeterministic behavior when the same address is reallocated. Don't build call graph nodes for debug intrinsic calls; they're useless, and there were typically a lot of them. llvm-svn: 67311 --- include/llvm/Transforms/IPO/InlinerPass.h | 7 +++++++ lib/Analysis/IPA/CallGraph.cpp | 3 ++- lib/Transforms/IPO/Inliner.cpp | 19 ++++++++++++------- lib/Transforms/IPO/PruneEH.cpp | 8 +++++--- 4 files changed, 26 insertions(+), 11 deletions(-) diff --git a/include/llvm/Transforms/IPO/InlinerPass.h b/include/llvm/Transforms/IPO/InlinerPass.h index 3aed6494b7c..a0a11a12c34 100644 --- a/include/llvm/Transforms/IPO/InlinerPass.h +++ b/include/llvm/Transforms/IPO/InlinerPass.h @@ -19,6 +19,9 @@ #include "llvm/CallGraphSCCPass.h" #include "llvm/Transforms/Utils/InlineCost.h" +#include "llvm/Target/TargetData.h" +#include + namespace llvm { class CallSite; @@ -43,6 +46,10 @@ struct Inliner : public CallGraphSCCPass { // processing to avoid breaking the SCC traversal. virtual bool doFinalization(CallGraph &CG); + // InlineCallIfPossible + bool InlineCallIfPossible(CallSite CS, CallGraph &CG, + const std::set &SCCFunctions, + const TargetData &TD); /// This method returns the value specified by the -inline-threshold value, /// specified on the command line. This is typically not directly needed. diff --git a/lib/Analysis/IPA/CallGraph.cpp b/lib/Analysis/IPA/CallGraph.cpp index ea7d7feb4cd..6dabcdb94bf 100644 --- a/lib/Analysis/IPA/CallGraph.cpp +++ b/lib/Analysis/IPA/CallGraph.cpp @@ -15,6 +15,7 @@ #include "llvm/Analysis/CallGraph.h" #include "llvm/Module.h" #include "llvm/Instructions.h" +#include "llvm/IntrinsicInst.h" #include "llvm/Support/CallSite.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Streams.h" @@ -143,7 +144,7 @@ private: for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE; ++II) { CallSite CS = CallSite::get(II); - if (CS.getInstruction()) { + if (CS.getInstruction() && !isa(II)) { const Function *Callee = CS.getCalledFunction(); if (Callee) Node->addCalledFunction(CS, getOrInsertFunction(Callee)); diff --git a/lib/Transforms/IPO/Inliner.cpp b/lib/Transforms/IPO/Inliner.cpp index ed177478e16..c38a6ae4149 100644 --- a/lib/Transforms/IPO/Inliner.cpp +++ b/lib/Transforms/IPO/Inliner.cpp @@ -16,6 +16,7 @@ #define DEBUG_TYPE "inline" #include "llvm/Module.h" #include "llvm/Instructions.h" +#include "llvm/IntrinsicInst.h" #include "llvm/Analysis/CallGraph.h" #include "llvm/Support/CallSite.h" #include "llvm/Target/TargetData.h" @@ -50,7 +51,7 @@ void Inliner::getAnalysisUsage(AnalysisUsage &Info) const { // InlineCallIfPossible - If it is possible to inline the specified call site, // do so and update the CallGraph for this operation. -static bool InlineCallIfPossible(CallSite CS, CallGraph &CG, +bool Inliner::InlineCallIfPossible(CallSite CS, CallGraph &CG, const std::set &SCCFunctions, const TargetData &TD) { Function *Callee = CS.getCalledFunction(); @@ -76,6 +77,8 @@ static bool InlineCallIfPossible(CallSite CS, CallGraph &CG, // Remove any call graph edges from the callee to its callees. CalleeNode->removeAllCalledFunctions(); + resetCachedCostInfo(CalleeNode->getFunction()); + // Removing the node for callee from the call graph and delete it. delete CG.removeFunctionFromModule(CalleeNode); ++NumDeleted; @@ -123,6 +126,7 @@ bool Inliner::shouldInline(CallSite CS) { bool Inliner::runOnSCC(const std::vector &SCC) { CallGraph &CG = getAnalysis(); + TargetData &TD = getAnalysis(); std::set SCCFunctions; DOUT << "Inliner visiting SCC:"; @@ -142,7 +146,8 @@ bool Inliner::runOnSCC(const std::vector &SCC) { for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) for (BasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) { CallSite CS = CallSite::get(I); - if (CS.getInstruction() && (!CS.getCalledFunction() || + if (CS.getInstruction() && !isa(I) && + (!CS.getCalledFunction() || !CS.getCalledFunction()->isDeclaration())) CallSites.push_back(CS); } @@ -186,11 +191,10 @@ bool Inliner::runOnSCC(const std::vector &SCC) { if (shouldInline(CS)) { Function *Caller = CS.getCaller(); // Attempt to inline the function... - if (InlineCallIfPossible(CS, CG, SCCFunctions, - getAnalysis())) { - // Remove any cached cost info for this caller, as inlining the callee - // has increased the size of the caller (which may be the same as the - // callee). + if (InlineCallIfPossible(CS, CG, SCCFunctions, TD)) { + // Remove any cached cost info for this caller, as inlining the + // callee has increased the size of the caller (which may be the + // same as the callee). resetCachedCostInfo(Caller); // Remove this call site from the list. If possible, use @@ -263,6 +267,7 @@ bool Inliner::removeDeadFunctions(CallGraph &CG, bool Changed = false; for (std::set::iterator I = FunctionsToRemove.begin(), E = FunctionsToRemove.end(); I != E; ++I) { + resetCachedCostInfo((*I)->getFunction()); delete CG.removeFunctionFromModule(*I); ++NumDeleted; Changed = true; diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp index c7a4b9766a5..2b52f464b67 100644 --- a/lib/Transforms/IPO/PruneEH.cpp +++ b/lib/Transforms/IPO/PruneEH.cpp @@ -20,6 +20,7 @@ #include "llvm/Constants.h" #include "llvm/Function.h" #include "llvm/Instructions.h" +#include "llvm/IntrinsicInst.h" #include "llvm/Analysis/CallGraph.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" @@ -235,9 +236,10 @@ void PruneEH::DeleteBasicBlock(BasicBlock *BB) { CallGraphNode *CGN = CG[BB->getParent()]; for (BasicBlock::iterator I = BB->end(), E = BB->begin(); I != E; ) { --I; - if (CallInst *CI = dyn_cast(I)) - CGN->removeCallEdgeFor(CI); - else if (InvokeInst *II = dyn_cast(I)) + if (CallInst *CI = dyn_cast(I)) { + if (!isa(I)) + CGN->removeCallEdgeFor(CI); + } else if (InvokeInst *II = dyn_cast(I)) CGN->removeCallEdgeFor(II); if (!I->use_empty()) I->replaceAllUsesWith(UndefValue::get(I->getType()));