[llvm] llvm-reduce: Fix assert if call type mismatches function type (PR #131981)

[Matt Arsenault via llvm-commits]

https://github.com/arsenm created https://github.com/llvm/llvm-project/pull/131981

This fixes asserting on IR with undefined behavior from calls
with a type that does not match the type of the target function.

Just ignore callsites which already didn't match the function
signature. This is the most straightforward fix, the reference
to the global will be replaced later anyway. A better implementation
would try to pad out unused arguments, particularly in the cases where
the signatures only differ in type and not count.

Fixes #69312

>From c1232e941348f80ad9890b211c38a3c56b16465a Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Wed, 19 Mar 2025 14:11:04 +0700
Subject: [PATCH] llvm-reduce: Fix assert if call type mismatches function type

This fixes asserting on IR with undefined behavior from calls
with a type that does not match the type of the target function.

Just ignore callsites which already didn't match the function
signature. This is the most straightforward fix, the reference
to the global will be replaced later anyway. A better implementation
would try to pad out unused arguments, particularly in the cases where
the signatures only differ in type and not count.

Fixes #69312
---
 ...ands-to-args-wrong-call-type-issue69312.ll | 44 +++++++++++++++++++
 .../deltas/ReduceOperandsToArgs.cpp           | 16 ++++++-
 2 files changed, 58 insertions(+), 2 deletions(-)
 create mode 100644 llvm/test/tools/llvm-reduce/operands-to-args-wrong-call-type-issue69312.ll

diff --git a/llvm/test/tools/llvm-reduce/operands-to-args-wrong-call-type-issue69312.ll b/llvm/test/tools/llvm-reduce/operands-to-args-wrong-call-type-issue69312.ll
new file mode 100644
index 0000000000000..542737b08ce2b
--- /dev/null
+++ b/llvm/test/tools/llvm-reduce/operands-to-args-wrong-call-type-issue69312.ll
@@ -0,0 +1,44 @@
+; RUN: llvm-reduce %s -o %t --abort-on-invalid-reduction --delta-passes=operands-to-args --test FileCheck --test-arg %s --test-arg --match-full-lines --test-arg --check-prefix=INTERESTING --test-arg --input-file
+; RUN: FileCheck %s --input-file %t --check-prefixes=REDUCED,INTERESTING
+
+; REDUCED-LABEL: define void @func(i32 %k, i32 %extra.arg, ptr %Global, ptr %Local) {
+
+; Keep one reference to the original value.
+; INTERESTING: %[[LOCAL:Local[0-9]*]] = alloca i32, align 4
+
+; Everything else must use the function argument.
+; REDUCED: store i32 21, ptr %Global, align 4
+; REDUCED: store i32 0, ptr %Local, align 4
+; REDUCED: store i32 0, ptr %Global, align 4
+
+; Do not add any arguments for %Keep and @GlobalKeep.
+; INTERESTING: %[[KEEP:LocalKeep[0-9]*]] = add i32 %k, 21
+; INTERESTING: store i32 %[[KEEP]], ptr @GlobalKeep, align 4
+
+; Do not add any arguments if the call type was already mismatched
+
+; INTERESTING-LABEL: define void @mismatched_func_caller() {
+; REDUCED:             call void @func(i32 21)
+
+ at Global = global i32 42
+ at GlobalKeep = global i32 42
+
+define void @func(i32 %k, i32 %extra.arg) {
+entry:
+  %Local = alloca i32, align 4
+  store i32 21, ptr @Global, align 4
+  store i32 0, ptr %Local, align 4
+  store i32 0, ptr @Global, align 4
+  %LocalKeep = add i32 %k, 21
+  store i32 %LocalKeep, ptr @GlobalKeep, align 4
+  ret void
+}
+
+; This call has the wrong signature for the original underlying call,
+; so getCalledFunction does not return a reference to the function.
+define void @mismatched_func_caller() {
+entry:
+  call void @func(i32 21)
+  ret void
+}
+
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp
index aff0b849e8b83..66d4bd3048171 100644
--- a/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp
+++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp
@@ -61,8 +61,20 @@ static void replaceFunctionCalls(Function *OldF, Function *NewF) {
   for (Use &U : OldF->uses()) {
     auto *CI = cast<CallBase>(U.getUser());
     assert(&U == &CI->getCalledOperandUse());
-    assert(CI->getCalledFunction() == OldF);
-    Callers.push_back(CI);
+
+    Function *CalledF = CI->getCalledFunction();
+    if (CalledF == OldF) {
+      Callers.push_back(CI);
+    } else {
+      // The call may have undefined behavior by calling a function with a
+      // mismatched signature. In this case, do not bother adjusting the
+      // callsites to pad with any new arguments.
+
+      // TODO: Better QoI to try to add new arguments to the end, and ignore
+      // existing mismatches.
+      assert(!CalledF && CI->getCalledOperand()->stripPointerCasts() == OldF &&
+             "only expected call and function signature mismatch");
+    }
   }
 
   // Call arguments for NewF.