[clang][driver] Treat unkonwn -flto= values as -flto

[tbaeder]

Summary

The current behavior was introduced in https://github.com/llvm/llvm-project/commit/1628486548420f85b3467026d54663d1516404f5 and simply ignores the options, which will of course not turn on any form of LTO. When they are passed, I think it's sensible to at least turn on full LTO.

This makes clang basically accept all -flto=val values and treat them like -flto=full. I didn't implement anything that checks for only =auto or =jobserver, I'm not sure if that would be the right thing to do.

Thoughts?

[tbaeder]

On second thought, rather only handle =auto and =jobserver and don't warn.

[steven_wu]

I don't think current implementation is the best idea. I think is better to make the gcc compatible LTO value to be a clang Driver only option, give them an option name, and handle them separately in driver to invoke correct fullLTO cc1 command, so that:

• The value remain invalid option for cc1 (CompilerInvocation should just error on that, just like now).
• The ignored value should not appear in the help or autocompletion.

[tbaeder]

Thanks for the feedback, I think this should work better.

[tbaeder]

Use hasFlag() instead of hasArg() in Driver.cpp

[steven_wu]

LGTM

clang/include/clang/Basic/DiagnosticDriverKinds.td

 def err_unsupported_cxx_abi : Error<"C++ ABI '%0' is not supported on target triple '%1'">;
 
 def note_cc1_round_trip_original : Note<"Original arguments in round-trip: %0">;
 def note_cc1_round_trip_generated : Note<"Generated arguments #%0 in round-trip: %1">;
 def remark_cc1_round_trip_generated : Remark<"Generated arguments #%0 in round-trip: %1">, InGroup<RoundTripCC1Args>;
 def err_cc1_round_trip_fail_then_ok : Error<"Original arguments parse failed, then succeeded in round-trip">;
 def err_cc1_round_trip_ok_then_fail : Error<"Generated arguments parse failed in round-trip">;
 def err_cc1_round_trip_mismatch : Error<"Generated arguments do not match in round-trip">;
+
+def warn_drv_treating_option_as : Warning<"Unknown option %0, treating as %1.">;
 }

clang/include/clang/Driver/Options.td

 def fdiagnostics_show_location_EQ : Joined<["-"], "fdiagnostics-show-location=">, Group<clang_ignored_f_Group>;
 
 defm fcheck_new : BooleanFFlag<"check-new">, Group<clang_ignored_f_Group>;
 defm caller_saves : BooleanFFlag<"caller-saves">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm reorder_blocks : BooleanFFlag<"reorder-blocks">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm branch_count_reg : BooleanFFlag<"branch-count-reg">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm default_inline : BooleanFFlag<"default-inline">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm fat_lto_objects : BooleanFFlag<"fat-lto-objects">, Group<clang_ignored_gcc_optimization_f_Group>;
-def : Flag<["-"], "flto=auto">, Group<clang_ignored_gcc_optimization_f_Group>;
-def : Flag<["-"], "flto=jobserver">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm friend_injection : BooleanFFlag<"friend-injection">, Group<clang_ignored_f_Group>;
 defm function_attribute_list : BooleanFFlag<"function-attribute-list">, Group<clang_ignored_f_Group>;
 defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gcse_after_reload: BooleanFFlag<"gcse-after-reload">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gcse_las: BooleanFFlag<"gcse-las">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gcse_sm: BooleanFFlag<"gcse-sm">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gnu : BooleanFFlag<"gnu">, Group<clang_ignored_f_Group>;

clang/lib/Driver/Driver.cpp

if (A)
     LTOName = A->getValue();
 
   LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
                 .Case("full", LTOK_Full)
                 .Case("thin", LTOK_Thin)
                 .Default(LTOK_Unknown);
 
   if (LTOMode == LTOK_Unknown) {
+    // Treat all other options as "full", but warn that the option
+    // value is unknown.
     assert(A);
-    Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName()
-                                                    << A->getValue();
+    Diag(diag::warn_drv_treating_option_as)
+        << A->getAsString(Args) << "-flto=full";
+    LTOMode = LTOK_Full;
   }
 }
 
 /// Compute the desired OpenMP runtime from the flags provided.
 Driver::OpenMPRuntimeKind Driver::getOpenMPRuntime(const ArgList &Args) const {
   StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
 
   const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);

clang/lib/Frontend/CompilerInvocation.cpp

#undef CODEGEN_OPTION_WITH_MARSHALLING
   }
 
   Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
   Opts.PrepareForThinLTO = false;
   if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
     StringRef S = A->getValue();
     if (S == "thin")
       Opts.PrepareForThinLTO = true;
-    else if (S != "full")
-      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
+    // -flto=full and invalid values are handled elsewhere.
   }
   if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
     if (IK.getLanguage() != Language::LLVM_IR)
       Diags.Report(diag::err_drv_argument_only_allowed_with)
           << A->getAsString(Args) << "-x ir";
     Opts.ThinLTOIndexFile =
         std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
   }

clang/test/Driver/clang_f_opts.c

 // RUN:     -fno-builtin-foobar                                               \
 // RUN:     -fno-builtin-strcat -fno-builtin-strcpy                           \
 // RUN:     -fno-var-tracking                                                 \
 // RUN:     -fno-unsigned-char                                                \
 // RUN:     -fno-signed-char                                                  \
 // RUN:     -fstrength-reduce -fno-strength-reduce                            \
 // RUN:     -finline-limit=1000                                               \
 // RUN:     -finline-limit                                                    \
-// RUN:     -flto=1                                                           \
 // RUN:     -falign-labels                                                    \
 // RUN:     -falign-labels=100                                                \
 // RUN:     -falign-loops                                                     \
 // RUN:     -falign-loops=100                                                 \
 // RUN:     -falign-jumps                                                     \
 // RUN:     -falign-jumps=100                                                 \
 // RUN:     -fexcess-precision=100                                            \
 // RUN:     -fbranch-count-reg                                                \

 // RUN:     -fweb                                                             \
 // RUN:     -fwhole-program                                                   \
 // RUN:     -fno-tree-dce -ftree-dce                                          \
 // RUN:     -fno-tree-ter -ftree-ter                                          \
 // RUN:     -fno-tree-vrp -ftree-vrp                                          \
 // RUN:     -fno-delete-null-pointer-checks -fdelete-null-pointer-checks      \
 // RUN:     -fno-inline-small-functions -finline-small-functions              \
 // RUN:     -fno-fat-lto-objects -ffat-lto-objects                            \
-// RUN:     -flto=auto -flto=jobserver                                        \
 // RUN:     -fno-merge-constants -fmerge-constants                            \
 // RUN:     -fno-caller-saves -fcaller-saves                                  \
 // RUN:     -fno-reorder-blocks -freorder-blocks                              \
 // RUN:     -fno-schedule-insns2 -fschedule-insns2                            \
 // RUN:     -fno-stack-check                                                  \
 // RUN:     -fno-check-new -fcheck-new                                        \
 // RUN:     -ffriend-injection                                                \
 // RUN:     -fno-implement-inlines -fimplement-inlines                        \

 // RUN: -fprofile-values                                                      \
 // RUN: -fschedule-insns                                                      \
 // RUN: -fsignaling-nans                                                      \
 // RUN: -fstrength-reduce                                                     \
 // RUN: -ftracer                                                              \
 // RUN: -funroll-all-loops                                                    \
 // RUN: -funswitch-loops                                                      \
 // RUN: -flto=1                                                               \
+// RUN: -flto=auto                                                            \
+// RUN: -flto=jobserver                                                       \
 // RUN: -falign-labels                                                        \
 // RUN: -falign-labels=100                                                    \
 // RUN: -falign-loops                                                         \
 // RUN: -falign-loops=100                                                     \
 // RUN: -falign-jumps                                                         \
 // RUN: -falign-jumps=100                                                     \
 // RUN: -fexcess-precision=100                                                \
 // RUN: -fbranch-count-reg                                                    \

 // CHECK-WARNING-DAG: optimization flag '-fprofile-correction' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fprofile-values' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fschedule-insns' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fsignaling-nans' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fstrength-reduce' is not supported
 // CHECK-WARNING-DAG: optimization flag '-ftracer' is not supported
 // CHECK-WARNING-DAG: optimization flag '-funroll-all-loops' is not supported
 // CHECK-WARNING-DAG: optimization flag '-funswitch-loops' is not supported
-// CHECK-WARNING-DAG: unsupported argument '1' to option 'flto='
+// CHECK-WARNING_DAG: Unknown option -flto=1, treating as -flto=full
+// CHECK-WARNING_DAG: Unknown option -flto=auto, treating as -flto=full
+// CHECK-WARNING_DAG: Unknown option -flto=jobserver, treating as -flto=full
 // CHECK-WARNING-DAG: optimization flag '-falign-labels' is not supported
 // CHECK-WARNING-DAG: optimization flag '-falign-labels=100' is not supported
 // CHECK-WARNING-DAG: optimization flag '-falign-loops' is not supported
 // CHECK-WARNING-DAG: optimization flag '-falign-loops=100' is not supported
 // CHECK-WARNING-DAG: optimization flag '-falign-jumps' is not supported
 // CHECK-WARNING-DAG: optimization flag '-falign-jumps=100' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fexcess-precision=100' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fbranch-count-reg' is not supported