MergeFunctions: handle self recursive functions correctly.

First, it fixes a crash where the eliminated function is still referenced.
This shows up if two equivalent self-recursive functions are merged and those functions are internal.
Fixes SR-4514, rdar://problem/31479425

Second, it avoids creating a not needed parameter for really equivalent self recursive functions.

Author: eeckstein

lib/LLVMPasses/LLVMMergeFunctions.cpp

@@ -782,20 +782,31 @@ bool SwiftMergeFunctions::deriveParams(ParamInfos &Params,
 
 /// Returns true if the \p OpIdx's constant operand in the current instruction
 /// does differ in any of the functions in \p FInfos.
+///
+/// But it accepts the case where all operands refer to their containing
+/// functions (in case of self recursive functions).
 bool SwiftMergeFunctions::constsDiffer(const FunctionInfos &FInfos,
                                        unsigned OpIdx) {
   Constant *CommonConst = nullptr;
+  bool matching = true;
+  bool selfReferencing = true;
 
   for (const FunctionInfo &FI : FInfos) {
     Value *Op = FI.CurrentInst->getOperand(OpIdx);
     if (Constant *C = dyn_cast<Constant>(Op)) {
+      if (C != FI.F)
+        selfReferencing = false;
+
       if (!CommonConst) {
         CommonConst = C;
       } else if (C != CommonConst) {
-        return true;
+        matching = false;
       }
+      if (!selfReferencing && !matching)
+        return true;
     }
   }
+  assert(selfReferencing || matching);
   return false;
 }
 
@@ -903,6 +914,7 @@ void SwiftMergeFunctions::mergeWithParams(const FunctionInfos &FInfos,
       assert(!isInEquivalenceClass(&*Iter->second));
       Iter->second->F = nullptr;
       FuncEntries.erase(Iter);
+      DEBUG(dbgs() << "    Erase " << OrigFunc->getName() << '\n');
       OrigFunc->eraseFromParent();
     } else {
       // Otherwise we need a thunk which calls the merged function.
@@ -1062,8 +1074,15 @@ bool SwiftMergeFunctions::replaceDirectCallers(Function *Old, Function *New,
     // Add the new parameters.
     for (const ParamInfo &PI : Params) {
       assert(ParamIdx < NewFuncTy->getNumParams());
-      NewArgs.push_back(PI.Values[FuncIdx]);
-      OldParamTypes.push_back(PI.Values[FuncIdx]->getType());
+      Constant *ArgValue = PI.Values[FuncIdx];
+
+      // Check if it's a self referencing function. We must not use the old
+      // function pointer as argument.
+      if (ArgValue == Old)
+        ArgValue = New;
+
+      NewArgs.push_back(ArgValue);
+      OldParamTypes.push_back(ArgValue->getType());
       ++ParamIdx;
     }
 
@@ -1080,6 +1099,7 @@ bool SwiftMergeFunctions::replaceDirectCallers(Function *Old, Function *New,
     CI->replaceAllUsesWith(NewCI);
     CI->eraseFromParent();
   }
+  assert(Old->use_empty() && "should have replaced all uses of old function");
   return Old->hasLocalLinkage();
 }
 

test/LLVMPasses/merge_func.ll

@@ -323,3 +323,72 @@ done:
 ; CHECK: ret i1
   ret i1 %result
 }
+
+; Check self recursive functions
+
+; CHECK-NOT: @recursive1(
+define internal void @recursive1(i32 %x, i32 %y) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @recursive1(i32 %x, i32 %y)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-LABEL: define internal void @recursive1_merged(i32, i32)
+; CHECK: call void @recursive1_merged(i32 %0, i32 %1)
+; CHECK: ret void
+define internal void @recursive2(i32 %x, i32 %y) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @recursive2(i32 %x, i32 %y)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-LABEL: define internal void @another_recursive_func_merged(i32, void (i32)*)
+; CHECK: call void %1(i32 %0)
+; CHECK: ret void
+define internal void @another_recursive_func(i32 %x) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @another_recursive_func(i32 %x)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-NOT: @not_really_recursive(
+define internal void @not_really_recursive(i32 %x) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @callee1(i32 %x)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-LABEL: define void @call_recursive_funcs(i32 %x)
+; CHECK: call void @recursive1_merged(i32 %x, i32 %x)
+; CHECK: call void @recursive1_merged(i32 %x, i32 %x)
+; CHECK: call void bitcast (void (i32, void (i32)*)* @another_recursive_func_merged to void (i32, void (i32, void (i32)*)*)*)(i32 %x, void (i32, void (i32)*)* @another_recursive_func_merged)
+; CHECK: call void @another_recursive_func_merged(i32 %x, void (i32)* @callee1)
+; CHECK: ret void
+define void @call_recursive_funcs(i32 %x) {
+  call void @recursive1(i32 %x, i32 %x)
+  call void @recursive2(i32 %x, i32 %x)
+  call void @another_recursive_func(i32 %x)
+  call void @not_really_recursive(i32 %x)
+  ret void
+}
+