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

@@ -19,6 +19,9 @@
 
 #include "llvm/CallGraphSCCPass.h"
 #include "llvm/Transforms/Utils/InlineCost.h"
+#include "llvm/Target/TargetData.h"
+#include <set>
+
 
 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<Function*> &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.

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<DbgInfoIntrinsic>(II)) {
           const Function *Callee = CS.getCalledFunction();
           if (Callee)
             Node->addCalledFunction(CS, getOrInsertFunction(Callee));

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<Function*> &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<CallGraphNode*> &SCC) {
   CallGraph &CG = getAnalysis<CallGraph>();
+  TargetData &TD = getAnalysis<TargetData>();
 
   std::set<Function*> SCCFunctions;
   DOUT << "Inliner visiting SCC:";
@@ -142,7 +146,8 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &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<DbgInfoIntrinsic>(I) &&
+                                     (!CS.getCalledFunction() ||
                                       !CS.getCalledFunction()->isDeclaration()))
             CallSites.push_back(CS);
         }
@@ -186,11 +191,10 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &SCC) {
         if (shouldInline(CS)) {
           Function *Caller = CS.getCaller();
           // Attempt to inline the function...
-          if (InlineCallIfPossible(CS, CG, SCCFunctions, 
-                                   getAnalysis<TargetData>())) {
-            // 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<CallGraphNode*>::iterator I = FunctionsToRemove.begin(),
          E = FunctionsToRemove.end(); I != E; ++I) {
+    resetCachedCostInfo((*I)->getFunction());
     delete CG.removeFunctionFromModule(*I);
     ++NumDeleted;
     Changed = true;

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<CallInst>(I))
-      CGN->removeCallEdgeFor(CI);
-    else if (InvokeInst *II = dyn_cast<InvokeInst>(I))
+    if (CallInst *CI = dyn_cast<CallInst>(I)) {
+      if (!isa<DbgInfoIntrinsic>(I))
+        CGN->removeCallEdgeFor(CI);
+    } else if (InvokeInst *II = dyn_cast<InvokeInst>(I))
       CGN->removeCallEdgeFor(II);
     if (!I->use_empty())
       I->replaceAllUsesWith(UndefValue::get(I->getType()));