[llvm] llvm-reduce: Avoid invalid reductions on x86_intrcc (PR #133396)

[Matt Arsenault via llvm-commits]

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

If there are arguments, the first one must be byval.

>From 8afdd1bb293974803fe76b12aa91a2124579960e Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Fri, 28 Mar 2025 15:23:32 +0700
Subject: [PATCH] llvm-reduce: Avoid invalid reductions on x86_intrcc

If there are arguments, the first one must be byval.
---
 .../reduce-arguments-x86_intrcc.ll            | 35 +++++++++++++++++++
 .../llvm-reduce/deltas/ReduceArguments.cpp    | 29 +++++++++++----
 2 files changed, 58 insertions(+), 6 deletions(-)
 create mode 100644 llvm/test/tools/llvm-reduce/reduce-arguments-x86_intrcc.ll

diff --git a/llvm/test/tools/llvm-reduce/reduce-arguments-x86_intrcc.ll b/llvm/test/tools/llvm-reduce/reduce-arguments-x86_intrcc.ll
new file mode 100644
index 0000000000000..50aac3cce32fa
--- /dev/null
+++ b/llvm/test/tools/llvm-reduce/reduce-arguments-x86_intrcc.ll
@@ -0,0 +1,35 @@
+; RUN: llvm-reduce %s -o %t --abort-on-invalid-reduction --delta-passes=arguments --test FileCheck --test-arg %s --test-arg --check-prefix=INTERESTING --test-arg --input-file
+; RUN: FileCheck %s --input-file %t --check-prefix=REDUCED
+
+ at gv = global i32 0
+
+; INTERESTING-LABEL: void @func(
+; INTERESTING-SAME: i32 %other.keep
+
+; REDUCED: define x86_intrcc void @func(ptr byval(i32) %k, i32 %other.keep)
+define x86_intrcc void @func(ptr byval(i32) %k, i32 %other.keep, i32 %other.drop) {
+  store i32 %other.keep, ptr @gv
+  ret void
+}
+
+; INTERESTING-LABEL: void @extern_decl(
+; INTERESTING-SAME: i32
+
+; REDUCED: declare x86_intrcc void @extern_decl(ptr byval(i32))
+declare x86_intrcc void @extern_decl(ptr byval(i32), i32, i32)
+
+; INTERESTING-LABEL: void @callsite(
+; INTERESTING: call
+; REDUCED: call x86_intrcc void @func(ptr %k, i32 %other.keep)
+define void @callsite(ptr %k, i32 %other.keep, i32 %other.drop) {
+  call x86_intrcc void @func(ptr byval(i32) %k, i32 %other.keep, i32 %other.drop)
+  ret void
+}
+
+; INTERESTING-LABEL: void @keep_none(
+; REDUCED-LABEL: define x86_intrcc void @keep_none()
+define x86_intrcc void @keep_none(ptr byval(i32) %k, i32 %other0, float %other1) {
+  store i32 %other0, ptr @gv
+  store float %other1, ptr @gv
+  ret void
+}
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp b/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp
index 5b1363d3293a6..134801fef020b 100644
--- a/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp
+++ b/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp
@@ -23,6 +23,19 @@
 
 using namespace llvm;
 
+static bool callingConvRequiresArgument(const Function &F,
+                                        const Argument &Arg) {
+  switch (F.getCallingConv()) {
+  case CallingConv::X86_INTR:
+    // If there are any arguments, the first one must by byval.
+    return Arg.getArgNo() == 0 && F.arg_size() != 1;
+  default:
+    return false;
+  }
+
+  llvm_unreachable("covered calling conv switch");
+}
+
 /// Goes over OldF calls and replaces them with a call to NewF
 static void replaceFunctionCalls(Function &OldF, Function &NewF,
                                  const std::set<int> &ArgIndexesToKeep) {
@@ -60,14 +73,18 @@ static void extractArgumentsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
   Module &Program = WorkItem.getModule();
   std::vector<Argument *> InitArgsToKeep;
   std::vector<Function *> Funcs;
+
   // Get inside-chunk arguments, as well as their parent function
-  for (auto &F : Program)
-    if (shouldRemoveArguments(F)) {
-      Funcs.push_back(&F);
-      for (auto &A : F.args())
-        if (O.shouldKeep())
-          InitArgsToKeep.push_back(&A);
+  for (auto &F : Program) {
+    if (!shouldRemoveArguments(F))
+      continue;
+
+    Funcs.push_back(&F);
+    for (auto &A : F.args()) {
+      if (callingConvRequiresArgument(F, A) || O.shouldKeep())
+        InitArgsToKeep.push_back(&A);
     }
+  }
 
   // We create a vector first, then convert it to a set, so that we don't have
   // to pay the cost of rebalancing the set frequently if the order we insert