[llvm-reduce] Skip updating calls where OldF isn't the called fn.

[fhahn]

Summary

When replacing function calls, skip call instructions where the old
function is not the called function, but e.g. the old function is passed
as an argument.

This fixes a crash due to trying to construct invalid IR for the test
case.

[lebedev.ri]

What if we are calling bitcasted OldF?

[fhahn]

In D109759#2999593, @lebedev.ri wrote:

What if we are calling bitcasted OldF?

It's undefined behavior, so that's not great.

But already we replace all remaining uses of the old function with a bitcast'd version of the new function, so it shouldn't make things worse much. E.g. I think even without this patch, we could have something like 'store OldF', 'load the stored fn' and call it. Or a no-op bit cast of OldF which is then passed to a call. Or a const global array which contains OldF. Those instances would have the same issue when replacing OldF with the bitcast'd version of NewF.

I guess we could skip replacing functions if there are non-call users, but that might be a bit limiting in terms of reduction power. Or keep around the old function as declaration or something.

[aeubanks]

reverse ping

llvm/test/tools/llvm-reduce/remove-args-fn-passed-through-call.ll

+; Test that llvm-reduce can remove uninteresting function arguments from function definitions as well as their calls.
+; This test checks that functions with different argument types are handled correctly
+;
+; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s --input-file %t
+
+declare void @pass(void (i32, i8*, i64*)*)
+
+define void @bar() {
+entry:
+  ; CHECK-INTERESTINGNESS: call void @pass({{.*}}@interesting
+  ; CHECK-FINAL: call void @pass(void (i32, i8*, i64*)* bitcast (void (i64*)* @interesting to void (i32, i8*, i64*)*))
+  call void @pass(void (i32, i8*, i64*)* @interesting)
+  ret void
+}
+
+; CHECK-ALL: define internal void @interesting
+; CHECK-INTERESTINGNESS-SAME: ({{.*}}%interesting{{.*}}) {
+; CHECK-FINAL-SAME: (i64* %interesting)
+define internal void @interesting(i32 %uninteresting1, i8* %uninteresting2, i64* %interesting) {
+entry:
+  ret void
+}

llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp

 using namespace llvm;
 
 /// Goes over OldF calls and replaces them with a call to NewF
 static void replaceFunctionCalls(Function &OldF, Function &NewF,
                                  const std::set<int> &ArgIndexesToKeep) {
   const auto &Users = OldF.users();
   for (auto I = Users.begin(), E = Users.end(); I != E; )
     if (auto *CI = dyn_cast<CallInst>(*I++)) {
+      // Skip uses in call instructions where OldF isn't the called function
+      // (e.g. if OldF is an argument of the call).
+      if (CI->getCalledFunction() != &OldF)
+        continue;
       SmallVector<Value *, 8> Args;
       for (auto ArgI = CI->arg_begin(), E = CI->arg_end(); ArgI != E; ++ArgI)
         if (ArgIndexesToKeep.count(ArgI - CI->arg_begin()))
           Args.push_back(*ArgI);
 
       CallInst *NewCI = CallInst::Create(&NewF, Args);
       NewCI->setCallingConv(NewF.getCallingConv());
       if (!CI->use_empty())