* Make sure the resolved function call instructions get the name from the

  old call instruction
* Implement conversion of return values for calls.  This fixes bug:
   test/Regression/Transforms/FunctionResolve/retmismatch3.ll

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

diff --git a/lib/Transforms/IPO/FunctionResolution.cpp b/lib/Transforms/IPO/FunctionResolution.cpp
index 44f8485121188b2df1b76cdc5a9e1f2cf7c9f6de..2306df999db67e16ce89c9767ca541a267eb4da6 100644 (file)
--- a/lib/Transforms/IPO/FunctionResolution.cpp
+++ b/lib/Transforms/IPO/FunctionResolution.cpp
@@ -80,6 +80,9 @@ static void ConvertCallTo(CallInst *CI, Function *Dest) {
   // Remove the old call instruction from the program...
   BB->getInstList().remove(BBI);
 
+  // Transfer the name over...
+  NewCall->setName(CI->getName());
+
   // Replace uses of the old instruction with the appropriate values...
   //
   if (NewCall->getType() == CI->getType()) {
@@ -94,10 +97,19 @@ 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()) {
+      CastInst *NewCast = new CastInst(NewCall, CI->getType(),
+                                       NewCall->getName());
+      CI->replaceAllUsesWith(NewCast);
+      // Insert the new cast instruction...
+      BB->getInstList().insert(BBI, NewCast);
+    }
   }
 
   // The old instruction is no longer needed, destroy it!
@@ -190,10 +202,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!");