Move the function extractor pass from tools/extract into lib/Xform/IPO

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4759 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Transforms/IPO.h

@@ -9,6 +9,7 @@
 #define LLVM_TRANSFORMS_IPO_H
 
 class Pass;
+class Function;
 
 //===----------------------------------------------------------------------===//
 // createConstantMergePass - This function returns a new pass that merges
@@ -34,6 +35,13 @@ Pass *createDeadTypeEliminationPass();
 Pass *createGlobalDCEPass();
 
 
+//===----------------------------------------------------------------------===//
+// createFunctionExtractionPass - This pass deletes as much of the module as
+// possible, except for the function specified.
+//
+Pass *createFunctionExtractionPass(Function *F);
+
+
 //===----------------------------------------------------------------------===//
 // FunctionResolvingPass - Go over the functions that are in the module and
 // look for functions that have the same name.  More often than not, there will

lib/Transforms/IPO/ExtractFunction.cpp

@@ -0,0 +1,83 @@
+
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Pass.h"
+#include "llvm/Module.h"
+
+namespace {
+  class FunctionExtractorPass : public Pass {
+    Function *Named;
+  public:
+    FunctionExtractorPass(Function *F = 0) : Named(F) {}
+
+    bool run(Module &M) {
+      if (Named == 0) {
+        Named = M.getMainFunction();
+        if (Named == 0) return false;  // No function to extract
+      }
+
+      // Make sure our result is globally accessable...
+      Named->setInternalLinkage(false);
+
+      // Mark all global variables internal
+      for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
+        if (!I->isExternal()) {
+          I->setInitializer(0);  // Make all variables external
+          I->setInternalLinkage(false); // Make sure it's not internal
+        }
+      
+      // 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...
+      
+      for (Module::iterator I = M.begin(); ; ++I) {
+        if (&*I != Named) {
+          Function *New = new Function(I->getFunctionType(),false,I->getName());
+          I->setName("");  // Remove Old name
+          
+          // If it's not the named function, delete the body of the function
+          I->dropAllReferences();
+          
+          M.getFunctionList().push_back(New);
+          NewFunctions.push_back(New);
+        }
+        
+        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.
+      if (!NewFunctions.empty()) {
+        unsigned FuncNum = 0;
+        Module::iterator I = M.begin();
+        do {
+          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;
+    }
+  };
+
+  RegisterPass<FunctionExtractorPass> X("extract", "Function Extractor");
+}
+
+Pass *createFunctionExtractionPass(Function *F) {
+  return new FunctionExtractorPass(F);
+}

tools/extract/extract.cpp

@@ -25,95 +25,6 @@ static cl::opt<std::string>
 ExtractFunc("func", cl::desc("Specify function to extract"), cl::init("main"),
             cl::value_desc("function"));
 
-
-struct FunctionExtractorPass : public Pass {
-  bool run(Module &M) {
-    // Mark all global variables to be internal
-    for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
-      if (!I->isExternal()) {
-        I->setInitializer(0);  // Make all variables external
-        I->setInternalLinkage(false); // Make sure it's not internal
-      }
-
-    Function *Named = 0;
-
-    // Loop over all of the functions in the module, dropping all references in
-    // functions that are not the named function.
-    for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
-      // Check to see if this is the named function!
-      if (I->getName() == ExtractFunc && !I->isExternal()) {
-        if (Named) {                            // Two functions, same name?
-          std::cerr << "extract ERROR: Two functions named: '" << ExtractFunc
-                    << "' found!\n";
-          exit(1);
-        }
-
-        // Yes, it is.  Keep track of it...
-        Named = I;
-
-        // Make sure it's globally accessable...
-        Named->setInternalLinkage(false);
-      }
-    
-    if (Named == 0) {
-      std::cerr << "Warning: Function '" << ExtractFunc << "' not found!\n";
-      return false;
-    }
-    
-    // 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...
-
-    for (Module::iterator I = M.begin(); ; ++I) {
-      if (I->getName() != ExtractFunc) {
-        Function *New = new Function(I->getFunctionType(), false, I->getName());
-        I->setName("");  // Remove Old name
-
-        // If it's not the named function, delete the body of the function
-        I->dropAllReferences();
-
-        M.getFunctionList().push_back(New);
-        NewFunctions.push_back(New);
-      }
-
-      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.
-    if (!NewFunctions.empty()) {
-      unsigned FuncNum = 0;
-      Module::iterator I = M.begin();
-      do {
-        if (I->getName() != ExtractFunc) {
-          // 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;
-  }
-};
-
-
-static RegisterPass<FunctionExtractorPass> X("extract", "Function Extractor");
-
-
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, " llvm extractor\n");
 
@@ -123,14 +34,21 @@ int main(int argc, char **argv) {
     return 1;
   }
 
+  // Figure out which function we should extract
+  Function *F = M.get()->getNamedFunction(ExtractFunc);
+  if (F == 0) {
+    std::cerr << argv[0] << ": program doesn't contain function named '"
+              << ExtractFunc << "'!\n";
+    return 1;
+  }
+
   // In addition to just parsing the input from GCC, we also want to spiff it up
   // a little bit.  Do this now.
   //
   PassManager Passes;
-  Passes.add(new FunctionExtractorPass());
+  Passes.add(createFunctionExtractionPass(F));    // Extract the function
   Passes.add(createGlobalDCEPass());              // Delete unreachable globals
   Passes.add(createFunctionResolvingPass());      // Delete prototypes
-  Passes.add(createConstantMergePass());          // Merge dup global constants
   Passes.add(createDeadTypeEliminationPass());    // Remove dead types...
   Passes.add(new WriteBytecodePass(&std::cout));  // Write bytecode to file...
 

tools/llvm-extract/llvm-extract.cpp

@@ -25,95 +25,6 @@ static cl::opt<std::string>
 ExtractFunc("func", cl::desc("Specify function to extract"), cl::init("main"),
             cl::value_desc("function"));
 
-
-struct FunctionExtractorPass : public Pass {
-  bool run(Module &M) {
-    // Mark all global variables to be internal
-    for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I)
-      if (!I->isExternal()) {
-        I->setInitializer(0);  // Make all variables external
-        I->setInternalLinkage(false); // Make sure it's not internal
-      }
-
-    Function *Named = 0;
-
-    // Loop over all of the functions in the module, dropping all references in
-    // functions that are not the named function.
-    for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
-      // Check to see if this is the named function!
-      if (I->getName() == ExtractFunc && !I->isExternal()) {
-        if (Named) {                            // Two functions, same name?
-          std::cerr << "extract ERROR: Two functions named: '" << ExtractFunc
-                    << "' found!\n";
-          exit(1);
-        }
-
-        // Yes, it is.  Keep track of it...
-        Named = I;
-
-        // Make sure it's globally accessable...
-        Named->setInternalLinkage(false);
-      }
-    
-    if (Named == 0) {
-      std::cerr << "Warning: Function '" << ExtractFunc << "' not found!\n";
-      return false;
-    }
-    
-    // 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...
-
-    for (Module::iterator I = M.begin(); ; ++I) {
-      if (I->getName() != ExtractFunc) {
-        Function *New = new Function(I->getFunctionType(), false, I->getName());
-        I->setName("");  // Remove Old name
-
-        // If it's not the named function, delete the body of the function
-        I->dropAllReferences();
-
-        M.getFunctionList().push_back(New);
-        NewFunctions.push_back(New);
-      }
-
-      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.
-    if (!NewFunctions.empty()) {
-      unsigned FuncNum = 0;
-      Module::iterator I = M.begin();
-      do {
-        if (I->getName() != ExtractFunc) {
-          // 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;
-  }
-};
-
-
-static RegisterPass<FunctionExtractorPass> X("extract", "Function Extractor");
-
-
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, " llvm extractor\n");
 
@@ -123,14 +34,21 @@ int main(int argc, char **argv) {
     return 1;
   }
 
+  // Figure out which function we should extract
+  Function *F = M.get()->getNamedFunction(ExtractFunc);
+  if (F == 0) {
+    std::cerr << argv[0] << ": program doesn't contain function named '"
+              << ExtractFunc << "'!\n";
+    return 1;
+  }
+
   // In addition to just parsing the input from GCC, we also want to spiff it up
   // a little bit.  Do this now.
   //
   PassManager Passes;
-  Passes.add(new FunctionExtractorPass());
+  Passes.add(createFunctionExtractionPass(F));    // Extract the function
   Passes.add(createGlobalDCEPass());              // Delete unreachable globals
   Passes.add(createFunctionResolvingPass());      // Delete prototypes
-  Passes.add(createConstantMergePass());          // Merge dup global constants
   Passes.add(createDeadTypeEliminationPass());    // Remove dead types...
   Passes.add(new WriteBytecodePass(&std::cout));  // Write bytecode to file...