[Clang][Driver] Add -fno-inline-functions-called-once; expose positive form in --help

Signed-off-by: Karthikdhondi <[email protected]>

Author: Karthikdhondi

clang/include/clang/Driver/Options.td

@@ -6959,8 +6959,12 @@ defm merge_constants : BooleanFFlag<"merge-constants">, Group<clang_ignored_gcc_
 defm modulo_sched : BooleanFFlag<"modulo-sched">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm modulo_sched_allow_regmoves : BooleanFFlag<"modulo-sched-allow-regmoves">,
     Group<clang_ignored_gcc_optimization_f_Group>;
-defm inline_functions_called_once : BooleanFFlag<"inline-functions-called-once">,
-    Group<clang_ignored_gcc_optimization_f_Group>;
+defm inline_functions_called_once
+  : BooleanFFlag<"inline-functions-called-once">,
+    Group<f_clang_Group>,
+    Visibility<[ClangOption, CC1Option]>,
+    HelpText<"Control inlining of TU-local functions called exactly once "
+             "(use -fno-inline-functions-called-once to inhibit it)">;
 def finline_limit_EQ : Joined<["-"], "finline-limit=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm finline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm inline_small_functions : BooleanFFlag<"inline-small-functions">,

clang/lib/Driver/ToolChains/Clang.cpp

@@ -7266,6 +7266,12 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
 
   Args.AddLastArg(CmdArgs, options::OPT_finline_max_stacksize_EQ);
 
+  // Forward -fno-inline-functions-called-once to LLVM so the pass is enabled.
+  if (Args.hasArg(options::OPT_fno_inline_functions_called_once)) {
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back("-no-inline-functions-called-once");
+  }
+
   // FIXME: Find a better way to determine whether we are in C++20.
   bool HaveCxx20 =
       Std &&

clang/test/CodeGen/no-inline-func-called-once.c

@@ -0,0 +1,32 @@
+// REQUIRES: x86-registered-target
+// RUN: %clang -O1 -S -emit-llvm %s -fno-inline-functions-called-once -o - | FileCheck %s --check-prefix=NOINLINE
+
+// We verify three things:
+//   1) There is a surviving call to bad_function (so it wasn’t inlined).
+//   2) bad_function’s definition exists and carries an attribute group id.
+//   3) That attribute group includes 'noinline'.
+
+// The call is earlier in the IR than the callee/attributes, so use -DAG for the
+// first two checks to avoid order constraints, then pin the attributes match.
+
+// NOINLINE-DAG: call{{.*}} @bad_function{{.*}}
+// NOINLINE-DAG: define internal{{.*}} @bad_function{{.*}} #[[ATTR:[0-9]+]]
+// NOINLINE: attributes #[[ATTR]] = { {{.*}}noinline{{.*}} }
+
+volatile int G;
+
+static void bad_function(void) {
+  // Volatile side effect ensures the call can’t be DCE’d.
+  G++;
+}
+
+static void test(void) {
+  // Exactly one TU-local caller of bad_function.
+  bad_function();
+}
+
+int main(void) {
+  // Make the caller reachable so it survives global DCE.
+  test();
+  return 0;
+}

clang/test/Driver/clang_f_opts.c

@@ -277,7 +277,6 @@
 // RUN:     -fgcse-las                                                        \
 // RUN:     -fgcse-sm                                                         \
 // RUN:     -fipa-cp                                                          \
-// RUN:     -finline-functions-called-once                                    \
 // RUN:     -fmodulo-sched                                                    \
 // RUN:     -fmodulo-sched-allow-regmoves                                     \
 // RUN:     -fpeel-loops                                                      \
@@ -349,7 +348,6 @@
 // RUN: -fgcse-las                                                            \
 // RUN: -fgcse-sm                                                             \
 // RUN: -fipa-cp                                                              \
-// RUN: -finline-functions-called-once                                        \
 // RUN: -fmodulo-sched                                                        \
 // RUN: -fmodulo-sched-allow-regmoves                                         \
 // RUN: -fpeel-loops                                                          \
@@ -409,7 +407,6 @@
 // CHECK-WARNING-DAG: optimization flag '-fgcse-las' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fgcse-sm' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fipa-cp' is not supported
-// CHECK-WARNING-DAG: optimization flag '-finline-functions-called-once' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fmodulo-sched' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fmodulo-sched-allow-regmoves' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fpeel-loops' is not supported

clang/test/Driver/fno-inline-functions-called-once.c

@@ -0,0 +1,20 @@
+// REQUIRES: x86-registered-target
+
+// Check that -fno-inline-functions-called-once is forwarded to LLVM.
+// RUN: %clang -### -S %s -fno-inline-functions-called-once 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=FWD
+// FWD: "-mllvm" "-no-inline-functions-called-once"
+
+// Check that the positive form does NOT forward anything to -mllvm.
+// RUN: %clang -### -S %s -finline-functions-called-once 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=POS
+// POS-NOT: -mllvm
+// POS-NOT: -no-inline-functions-called-once
+
+// Help text should show both flags (order-independent).
+// RUN: %clang --help 2>&1 | FileCheck %s --check-prefix=HELP
+// HELP-DAG: -finline-functions-called-once
+// HELP-DAG: -fno-inline-functions-called-once
+
+int x;
+