Non-functionality change just to make it more clear what is going on

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

diff --git a/lib/Transforms/IPO/FunctionResolution.cpp b/lib/Transforms/IPO/FunctionResolution.cpp
index 6cb901b79fe0dacdc240e6ce27c8a8561c3f1862..bf65c49bf9ec3af3ca8bf4b03f596ddc4875d629 100644 (file)
--- a/lib/Transforms/IPO/FunctionResolution.cpp
+++ b/lib/Transforms/IPO/FunctionResolution.cpp
@@ -11,15 +11,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/CleanupGCCOutput.h"
+#include "llvm/Transforms/IPO.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Pass.h"
 #include "llvm/iOther.h"
 #include "llvm/Constant.h"
-#include "Support/StatisticReporter.h"
-#include <iostream>
+#include "Support/Statistic.h"
 #include <algorithm>
 
 using std::vector;
@@ -27,13 +26,12 @@ using std::string;
 using std::cerr;
 
 namespace {
-  Statistic<>NumResolved("funcresolve\t- Number of varargs functions resolved");
+  Statistic<>NumResolved("funcresolve", "Number of varargs functions resolved");
 
   struct FunctionResolvingPass : public Pass {
-    const char *getPassName() const { return "Resolve Functions"; }
-
     bool run(Module &M);
   };
+  RegisterOpt<FunctionResolvingPass> X("funcresolve", "Resolve Functions");
 }
 
 Pass *createFunctionResolvingPass() {
@@ -62,25 +60,24 @@ static void ConvertCallTo(CallInst *CI, Function *Dest) {
   for (unsigned i = 1; i < CI->getNumOperands(); ++i) {
     Value *V = CI->getOperand(i);
 
-    if (V->getType() != ParamTys[i-1]) { // Must insert a cast...
-      Instruction *Cast = new CastInst(V, ParamTys[i-1]);
-      BBI = ++BB->getInstList().insert(BBI, Cast);
-      V = Cast;
-    }
+    if (V->getType() != ParamTys[i-1])  // Must insert a cast...
+      V = new CastInst(V, ParamTys[i-1], "argcast", BBI);
 
     Params.push_back(V);
   }
 
-  Instruction *NewCall = new CallInst(Dest, Params);
-
   // Replace the old call instruction with a new call instruction that calls
   // the real function.
   //
-  BBI = ++BB->getInstList().insert(BBI, NewCall);
+  Instruction *NewCall = new CallInst(Dest, Params, "", BBI);
 
   // Remove the old call instruction from the program...
   BB->getInstList().remove(BBI);
 
+  // Transfer the name over...
+  if (NewCall->getType() != Type::VoidTy)
+    NewCall->setName(CI->getName());
+
   // Replace uses of the old instruction with the appropriate values...
   //
   if (NewCall->getType() == CI->getType()) {
@@ -95,10 +92,18 @@ static void ConvertCallTo(CallInst *CI, Function *Dest) {
     CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
   } else if (CI->getType() == Type::VoidTy) {
     // If we are gaining a new return value, we don't have to do anything
-    // special.
+    // special here, because it will automatically be ignored.
   } else {
-    assert(0 && "This should have been checked before!");
-    abort();
+    // Insert a cast instruction to convert the return value of the function
+    // into it's new type.  Of course we only need to do this if the return
+    // value of the function is actually USED.
+    //
+    if (!CI->use_empty()) {
+      // Insert the new cast instruction...
+      CastInst *NewCast = new CastInst(NewCall, CI->getType(),
+                                       NewCall->getName(), BBI);
+      CI->replaceAllUsesWith(NewCast);
+    }
   }
 
   // The old instruction is no longer needed, destroy it!
@@ -122,8 +127,11 @@ bool FunctionResolvingPass::run(Module &M) {
         SymbolTable::VarMap &Plane = I->second;
         for (SymbolTable::type_iterator PI = Plane.begin(), PE = Plane.end();
              PI != PE; ++PI) {
-          const string &Name = PI->first;
-          Functions[Name].push_back(cast<Function>(PI->second));          
+          Function *F = cast<Function>(PI->second);
+          assert(PI->first == F->getName() &&
+                 "Function name and symbol table do not agree!");
+          if (F->hasExternalLinkage())  // Only resolve decls to external fns
+            Functions[PI->first].push_back(F);
         }
       }
 
@@ -139,6 +147,7 @@ bool FunctionResolvingPass::run(Module &M) {
     Function *Concrete = 0;
     for (unsigned i = 0; i < Functions.size(); ) {
       if (!Functions[i]->isExternal()) {  // Found an implementation
+        if (Implementation != 0)
         assert(Implementation == 0 && "Multiple definitions of the same"
                " function. Case not handled yet!");
         Implementation = Functions[i];
@@ -187,10 +196,6 @@ bool FunctionResolvingPass::run(Module &M) {
             const FunctionType *ConcreteMT = Concrete->getFunctionType();
             bool Broken = false;
 
-            assert((Old->getReturnType() == Concrete->getReturnType() ||
-                    Concrete->getReturnType() == Type::VoidTy ||
-                    Old->getReturnType() == Type::VoidTy) &&
-                   "Differing return types not handled yet!");
             assert(OldMT->getParamTypes().size() <=
                    ConcreteMT->getParamTypes().size() &&
                    "Concrete type must have more specified parameters!");