Make Transforms to be 4.3 warnings-clean

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

diff --git a/lib/Transforms/IPO/ExtractFunction.cpp b/lib/Transforms/IPO/ExtractFunction.cpp
index 41b796035b26165f6b1809b6ea636e258a17bf30..918d52d17ad9ec3e197b9dd352032cf79e08e39f 100644 (file)
--- a/lib/Transforms/IPO/ExtractFunction.cpp
+++ b/lib/Transforms/IPO/ExtractFunction.cpp
@@ -1,49 +1,74 @@
 //===-- ExtractFunction.cpp - Function extraction pass --------------------===//
-// 
+//
 //                     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.
+//
 //===----------------------------------------------------------------------===//
 //
 // This pass extracts
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/IPO.h"
+#include "llvm/Support/Compiler.h"
 using namespace llvm;
 
 namespace {
-  class FunctionExtractorPass : public Pass {
+  /// @brief A pass to extract specific functions and their dependencies.
+  class VISIBILITY_HIDDEN FunctionExtractorPass : public ModulePass {
     Function *Named;
     bool deleteFunc;
+    bool reLink;
   public:
+    static char ID; // Pass identification, replacement for typeid
+
     /// FunctionExtractorPass - If deleteFn is true, this pass deletes as the
     /// specified function. Otherwise, it deletes as much of the module as
     /// possible, except for the function specified.
     ///
-    FunctionExtractorPass(Function *F = 0, bool deleteFn = true) 
-      : Named(F), deleteFunc(deleteFn) {}
+    explicit FunctionExtractorPass(Function *F = 0, bool deleteFn = true,
+                                   bool relinkCallees = false)
+      : ModulePass((intptr_t)&ID), Named(F), deleteFunc(deleteFn), 
+      reLink(relinkCallees) {}
 
-    bool run(Module &M) {
+    bool runOnModule(Module &M) {
       if (Named == 0) {
-        Named = M.getMainFunction();
+        Named = M.getFunction("main");
         if (Named == 0) return false;  // No function to extract
       }
-
+      
       if (deleteFunc)
         return deleteFunction();
-      else 
-        return isolateFunction(M);
+      M.setModuleInlineAsm("");
+      return isolateFunction(M);
     }
 
     bool deleteFunction() {
+      // If we're in relinking mode, set linkage of all internal callees to
+      // external. This will allow us extract function, and then - link
+      // everything together
+      if (reLink) {
+        for (Function::iterator B = Named->begin(), BE = Named->end();
+             B != BE; ++B) {
+          for (BasicBlock::iterator I = B->begin(), E = B->end();
+               I != E; ++I) {
+            if (CallInst* callInst = dyn_cast<CallInst>(&*I)) {
+              Function* Callee = callInst->getCalledFunction();
+              if (Callee && Callee->hasInternalLinkage())
+                Callee->setLinkage(GlobalValue::ExternalLinkage);
+            }
+          }
+        }
+      }
+      
       Named->setLinkage(GlobalValue::ExternalLinkage);
       Named->deleteBody();
-      assert(Named->isExternal() && "This didn't make the function external!");
+      assert(Named->isDeclaration() && "This didn't make the function external!");
       return true;
     }
 
@@ -52,36 +77,39 @@ namespace {
       Named->setLinkage(GlobalValue::ExternalLinkage);
 
       // Mark all global variables internal
-      for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
-        if (!I->isExternal()) {
+      for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I)
+        if (!I->isDeclaration()) {
           I->setInitializer(0);  // Make all variables external
           I->setLinkage(GlobalValue::ExternalLinkage);
         }
-      
+
       // All of the functions may be used by global variables or the named
       // function.  Loop through them and create a new, external functions that
       // can be "used", instead of ones with bodies.
       std::vector<Function*> NewFunctions;
-      
-      Function *Last = &M.back();  // Figure out where the last real fn is...
-      
+
+      Function *Last = --M.end();  // Figure out where the last real fn is.
+
       for (Module::iterator I = M.begin(); ; ++I) {
         if (&*I != Named) {
           Function *New = new Function(I->getFunctionType(),
-                                       GlobalValue::ExternalLinkage,
-                                       I->getName());
-          I->setName("");  // Remove Old name
-          
+                                       GlobalValue::ExternalLinkage);
+          New->setCallingConv(I->getCallingConv());
+          New->setParamAttrs(I->getParamAttrs());
+          if (I->hasCollector())
+            New->setCollector(I->getCollector());
+
           // If it's not the named function, delete the body of the function
           I->dropAllReferences();
-          
+
           M.getFunctionList().push_back(New);
           NewFunctions.push_back(New);
+          New->takeName(I);
         }
-        
+
         if (&*I == Last) break;  // Stop after processing the last function
       }
-      
+
       // Now that we have replacements all set up, loop through the module,
       // deleting the old functions, replacing them with the newly created
       // functions.
@@ -92,26 +120,28 @@ namespace {
           if (&*I != Named) {
             // Make everything that uses the old function use the new dummy fn
             I->replaceAllUsesWith(NewFunctions[FuncNum++]);
-            
+
             Function *Old = I;
             ++I;  // Move the iterator to the new function
-            
+
             // Delete the old function!
             M.getFunctionList().erase(Old);
-            
+
           } else {
             ++I;  // Skip the function we are extracting
           }
         } while (&*I != NewFunctions[0]);
       }
-      
+
       return true;
     }
   };
 
+  char FunctionExtractorPass::ID = 0;
   RegisterPass<FunctionExtractorPass> X("extract", "Function Extractor");
 }
 
-Pass *llvm::createFunctionExtractionPass(Function *F, bool deleteFn) {
-  return new FunctionExtractorPass(F, deleteFn);
+ModulePass *llvm::createFunctionExtractionPass(Function *F, bool deleteFn,
+                                               bool relinkCallees) {
+  return new FunctionExtractorPass(F, deleteFn, relinkCallees);
 }