[llvm-commits] CVS: llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp ExtractFunction.cpp

[Anton Korobeynikov]

Changes in directory llvm/lib/Transforms/IPO:

DeadArgumentElimination.cpp updated: 1.34 -> 1.35
ExtractFunction.cpp updated: 1.15 -> 1.16
---
Log message:

Propagate changes from my local tree. This patch includes:
1. New parameter attribute called 'inreg'. It has meaning "place this 
parameter in registers, if possible". This is some generalization of 
gcc's regparm(n) attribute. It's currently used only in X86-32 backend.
2. Completely rewritten CC handling/lowering code inside X86 backend. 
Merged stdcall + c CCs and fastcall + fast CC.
3. Dropped CSRET CC. We cannot add struct return variant for each 
target-specific CC (e.g. stdcall + csretcc and so on).
4. Instead of CSRET CC introduced 'sret' parameter attribute. Setting in 
on first attribute has meaning 'This is hidden pointer to structure 
return. Handle it gently'.
5. Fixed small bug in llvm-extract + add new feature to 
FunctionExtraction pass, which relinks all internal-linkaged callees 
from deleted function to external linkage. This will allow further 
linking everything together.

NOTEs: 1. Documentation will be updated soon. 
       2. llvm-upgrade should be improved to translate csret => sret. 
          Before this, there will be some unexpected test fails.


---
Diffs of the changes:  (+29 -7)

 DeadArgumentElimination.cpp |    7 ++++---
 ExtractFunction.cpp         |   29 +++++++++++++++++++++++++----
 2 files changed, 29 insertions(+), 7 deletions(-)


Index: llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
diff -u llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp:1.34 llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp:1.35
--- llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp:1.34	Sat Dec 30 23:48:39 2006
+++ llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp	Sun Jan 28 07:31:35 2007
@@ -230,9 +230,10 @@
 // (used in a computation), MaybeLive (only passed as an argument to a call), or
 // Dead (not used).
 DAE::Liveness DAE::getArgumentLiveness(const Argument &A) {
-  // If this is the return value of a csret function, it's not really dead.
-  if (A.getParent()->getCallingConv() == CallingConv::CSRet &&
-      &*A.getParent()->arg_begin() == &A)
+  const FunctionType *FTy = A.getParent()->getFunctionType();
+  
+  // If this is the return value of a struct function, it's not really dead.
+  if (FTy->isStructReturn() && &*A.getParent()->arg_begin() == &A)
     return Live;
   
   if (A.use_empty())  // First check, directly dead?


Index: llvm/lib/Transforms/IPO/ExtractFunction.cpp
diff -u llvm/lib/Transforms/IPO/ExtractFunction.cpp:1.15 llvm/lib/Transforms/IPO/ExtractFunction.cpp:1.16
--- llvm/lib/Transforms/IPO/ExtractFunction.cpp:1.15	Thu Jan 25 11:38:26 2007
+++ llvm/lib/Transforms/IPO/ExtractFunction.cpp	Sun Jan 28 07:31:35 2007
@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/IPO.h"
@@ -20,13 +21,15 @@
   class FunctionExtractorPass : public ModulePass {
     Function *Named;
     bool deleteFunc;
+    bool reLink;
   public:
     /// 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) {}
+    FunctionExtractorPass(Function *F = 0, bool deleteFn = true,
+                          bool relinkCallees = false)
+      : Named(F), deleteFunc(deleteFn), reLink(relinkCallees) {}
 
     bool runOnModule(Module &M) {
       if (Named == 0) {
@@ -41,6 +44,23 @@
     }
 
     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!");
@@ -113,6 +133,7 @@
   RegisterPass<FunctionExtractorPass> X("extract", "Function Extractor");
 }
 
-ModulePass *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);
 }