Add toggling for -fnew-infallible/-fno-new-infallible

[modimo]

Summary

Allow toggling of -fnew-infallible so last instance takes precedence

Testing:
ninja check-all

[modimo]

Remove whitespace change

[bruno]

Hi @modimo, can you also add a driver test to check (clang/test/Driver/...) that nothing is added to cc1 cmdline when -fno-new-infallible is used or take precendence?

[modimo]

Add driver test

[modimo]

Gentle ping @bruno

[bruno]

LGTM

clang/docs/ClangCommandLineReference.rst

 .. option:: -fmudflapth
 
 .. option:: -fnested-functions
 
 .. option:: -fnew-alignment=<align>, -fnew-alignment <arg>
 
 Specifies the largest alignment guaranteed by '::operator new(size\_t)'
 
-.. option:: -fnew-infallible
+.. option:: -fnew-infallible, -fno-new-infallible
 
-Treats throwing global C++ operator new as always returning valid memory (annotates with \_\_attribute\_\_((returns\_nonnull)) and throw()). This is detectable in source.
+Enable treating throwing global C++ operator new as always returning valid memory (annotates with \_\_attribute\_\_((returns\_nonnull)) and throw()). This is detectable in source.
 
 .. option:: -fnext-runtime
 
 .. option:: -fno-builtin-<arg>
 
 Disable implicit builtin knowledge of a specific function
 
 .. option:: -fno-elide-type

clang/include/clang/Driver/Options.td

defm visibility_inlines_hidden_static_local_var : BoolFOption<"visibility-inlines-hidden-static-local-var",
   NegFlag<SetFalse, [], "Disables -fvisibility-inlines-hidden-static-local-var"
          " (this is the default on non-darwin targets)">, BothFlags<[CC1Option]>>;
 def fvisibility_ms_compat : Flag<["-"], "fvisibility-ms-compat">, Group<f_Group>,
   HelpText<"Give global types 'default' visibility and global functions and "
            "variables 'hidden' visibility by default">;
 def fvisibility_global_new_delete_hidden : Flag<["-"], "fvisibility-global-new-delete-hidden">, Group<f_Group>,
   HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>,
   MarshallingInfoFlag<LangOpts<"GlobalAllocationFunctionVisibilityHidden">>;
-def fnew_infallible : Flag<["-"], "fnew-infallible">, Group<f_Group>,
-  HelpText<"Treats throwing global C++ operator new as always returning valid memory "
-  "(annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.">,
-  Flags<[CC1Option]>, MarshallingInfoFlag<LangOpts<"NewInfallible">>;
+defm new_infallible : BoolFOption<"new-infallible",
+  LangOpts<"NewInfallible">, DefaultFalse,
+  PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [], "Disable">,
+  BothFlags<[CC1Option], " treating throwing global C++ operator new as always returning valid memory "
+  "(annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.">>;
 defm whole_program_vtables : BoolFOption<"whole-program-vtables",
   CodeGenOpts<"WholeProgramVTables">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Enables whole-program vtable optimization. Requires -flto">,
   NegFlag<SetFalse>, BothFlags<[CoreOption]>>;
 defm split_lto_unit : BoolFOption<"split-lto-unit",
   CodeGenOpts<"EnableSplitLTOUnit">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Enables splitting of the LTO unit">,
   NegFlag<SetFalse>, BothFlags<[CoreOption]>>;

clang/lib/Driver/ToolChains/Clang.cpp

 
   if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden,
                     options::OPT_fno_visibility_inlines_hidden, false))
     CmdArgs.push_back("-fvisibility-inlines-hidden");
 
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var,
                            options::OPT_fno_visibility_inlines_hidden_static_local_var);
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
-  Args.AddLastArg(CmdArgs, options::OPT_fnew_infallible);
   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
 
+  if (Args.hasFlag(options::OPT_fnew_infallible,
+                   options::OPT_fno_new_infallible, false))
+    CmdArgs.push_back("-fnew-infallible");
+
   if (Args.hasFlag(options::OPT_fno_operator_names,
                    options::OPT_foperator_names, false))
     CmdArgs.push_back("-fno-operator-names");
 
   // Forward -f (flag) options which we can pass directly.
   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
   Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);

clang/test/CodeGenCXX/new-infallible.cpp

 // RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fnew-infallible -o - %s | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fno-new-infallible -fnew-infallible -o - %s | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fno-new-infallible -o - %s | FileCheck %s --check-prefix=NO-NEW-INFALLIBLE
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fnew-infallible -fno-new-infallible -o - %s | FileCheck %s --check-prefix=NO-NEW-INFALLIBLE
 
 // CHECK: call noalias nonnull i8* @_Znwm(i64 4)
 
 // CHECK: ; Function Attrs: nobuiltin nounwind allocsize(0)
 // CHECK-NEXT: declare nonnull i8* @_Znwm(i64)
+
+// NO-NEW-INFALLIBLE: call noalias nonnull i8* @_Znwm(i64 4)
+
+// NO-NEW-INFALLIBLE: ; Function Attrs: nobuiltin allocsize(0)
+// NO-NEW-INFALLIBLE-NEXT: declare nonnull i8* @_Znwm(i64)
+
 int *new_infallible = new int;

clang/test/Driver/new-infallible.cpp

+// RUN: %clang -### -S -fno-new-infallible -fnew-infallible %s 2>&1 | FileCheck --check-prefix=NEW-INFALLIBLE %s
+// NEW-INFALLIBLE: "-fnew-infallible"
+
+// RUN: %clang -### -S -fnew-infallible -fno-new-infallible %s 2>&1 | FileCheck --check-prefix=NO-NEW-INFALLIBLE %s
+// NO-NEW-INFALLIBLE-NOT: "-fnew-infallible"
 No newline at end of file