Remove attribution from file headers, per discussion on llvmdev.

[oota-llvm.git] / lib / Transforms / IPO / Inliner.cpp

diff --git a/lib/Transforms/IPO/Inliner.cpp b/lib/Transforms/IPO/Inliner.cpp
index ea43dc21da356f11f2fdf668c001e9c386a41372..ca8eec48b4a7b75e7a9ab741f057fae0de537c73 100644 (file)
--- a/lib/Transforms/IPO/Inliner.cpp
+++ b/lib/Transforms/IPO/Inliner.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -13,11 +13,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "Inliner.h"
+#define DEBUG_TYPE "inline"
 #include "llvm/Module.h"
 #include "llvm/Instructions.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Support/CallSite.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Transforms/IPO/InlinerPass.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
@@ -25,23 +27,33 @@
 #include <set>
 using namespace llvm;
 
+STATISTIC(NumInlined, "Number of functions inlined");
+STATISTIC(NumDeleted, "Number of functions deleted because all callers found");
+
 namespace {
-  Statistic<> NumInlined("inline", "Number of functions inlined");
-  Statistic<> NumDeleted("inline",
-                       "Number of functions deleted because all callers found");
   cl::opt<unsigned>             // FIXME: 200 is VERY conservative
   InlineLimit("inline-threshold", cl::Hidden, cl::init(200),
         cl::desc("Control the amount of inlining to perform (default = 200)"));
 }
 
-Inliner::Inliner() : InlineThreshold(InlineLimit) {}
+Inliner::Inliner(const void *ID) 
+  : CallGraphSCCPass((intptr_t)ID), InlineThreshold(InlineLimit) {}
+
+/// getAnalysisUsage - For this class, we declare that we require and preserve
+/// the call graph.  If the derived class implements this method, it should
+/// always explicitly call the implementation here.
+void Inliner::getAnalysisUsage(AnalysisUsage &Info) const {
+  Info.addRequired<TargetData>();
+  CallGraphSCCPass::getAnalysisUsage(Info);
+}
 
 // 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,
-                                 const std::set<Function*> &SCCFunctions) {
+                                 const std::set<Function*> &SCCFunctions,
+                                 const TargetData &TD) {
   Function *Callee = CS.getCalledFunction();
-  if (!InlineFunction(CS, &CG)) return false;
+  if (!InlineFunction(CS, &CG, &TD)) return false;
 
   // If we inlined the last possible call site to the function, delete the
   // function body now.
@@ -51,7 +63,7 @@ static bool InlineCallIfPossible(CallSite CS, CallGraph &CG,
 
     // Remove any call graph edges from the callee to its callees.
     CallGraphNode *CalleeNode = CG[Callee];
-    while (CalleeNode->begin() != CalleeNode->end())
+    while (!CalleeNode->empty())
       CalleeNode->removeCallEdgeTo((CalleeNode->end()-1)->second);
 
     // Removing the node for callee from the call graph and delete it.
@@ -83,7 +95,7 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &SCC) {
         for (BasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) {
           CallSite CS = CallSite::get(I);
           if (CS.getInstruction() && (!CS.getCalledFunction() ||
-                                      !CS.getCalledFunction()->isExternal()))
+                                      !CS.getCalledFunction()->isDeclaration()))
             CallSites.push_back(CS);
         }
 
@@ -108,7 +120,7 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &SCC) {
     for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi)
       if (Function *Callee = CallSites[CSi].getCalledFunction()) {
         // Calls to external functions are never inlinable.
-        if (Callee->isExternal() ||
+        if (Callee->isDeclaration() ||
             CallSites[CSi].getInstruction()->getParent()->getParent() ==Callee){
           if (SCC.size() == 1) {
             std::swap(CallSites[CSi], CallSites.back());
@@ -133,7 +145,8 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &SCC) {
                << ", Call: " << *CS.getInstruction();
 
           // Attempt to inline the function...
-          if (InlineCallIfPossible(CS, CG, SCCFunctions)) {
+          if (InlineCallIfPossible(CS, CG, SCCFunctions, 
+                                   getAnalysis<TargetData>())) {
             // Remove this call site from the list.  If possible, use 
             // swap/pop_back for efficiency, but do not use it if doing so would
             // move a call site to a function in this SCC before the
@@ -175,7 +188,7 @@ bool Inliner::doFinalization(CallGraph &CG) {
           F->use_empty()) {
 
         // Remove any call graph edges from the function to its callees.
-        while (CGN->begin() != CGN->end())
+        while (!CGN->empty())
           CGN->removeCallEdgeTo((CGN->end()-1)->second);
 
         // Remove any edges from the external node to the function's call graph