[flang][driver] Update the visibility of Clang options in Flang

[awarzynski]

Summary

Prior to D157151, there was no mechanism to "disable" unsupported Clang
options in Flang. While the "help" text (flang-new -help) was indeed
configured not to display such options, the Flang compiler driver would
happily consume such options and only issue a warning when there was no
logic to parse it:

flang-new -fno-experimental-relative-c++-abi-vtables file.f90
flang-new: warning: argument unused during compilation: '-fno-experimental-relative-c++-abi-vtables'

D157151 introduces visibility flags. In particular, all Clang options
gain a visibility flag (Default) that can be excluded when in Flang
driver mode. This way the above invocation will lead to:

flang-new: error: unknown argument '-fno-experimental-relative-c++-abi-vtables'; did you mean '-Xclang -fno-experimental-relative-c++-abi-vtables'?

This won't work unless all options/flags supported by Flang have their
visibility flags updated accordingly, hence the changes in Options.td.
Moving forward, this change will allow Flang better control over the
supported options.

Depends on D157151

[tblah]

clang/lib/Driver/Driver.cpp

6497–6498

I presume this TODO can go now?

flang/test/Driver/target-cpu-features.f90

14 ↗

(On Diff #549810)

Why doesn't this fail now?

[bogner]

I can't speak to which flags should be present in flang-new or not, but in principle this looks great. You'll need to update the patch to use the "ClangOption" spelling rather than "Default" of course, as discussed in https://reviews.llvm.org/D157151

clang/lib/Driver/Driver.cpp

6497–6498

We can remove the TODO comment with this change :)

[DavidTruby]

This looks good to me (minus the issue @tblah mentioned), while this will mean that we also error on gfortran options we don't recognize, I don't personally think that's a problem as in my personal experience Fortran users are used to different compilers accepting different options and dealing with that.

[awarzynski]

Thank you all for reviewing!

In D157837#4584387, @bogner wrote:

I can't speak to which flags should be present in flang-new or not

That's determined by what's tested/used in tests.

You'll need to update the patch to use the "ClangOption" spelling rather than "Default" of course, as discussed in https://reviews.llvm.org/D157151

Yup, no problem. I may wait for your changes to land first.

flang/test/Driver/target-cpu-features.f90

14 ↗

(On Diff #549810)

Missing TargetSpecific flag in the definition of the mcpu_EQ option. Sorry i didn't have time to debug earlier. To be fixed in the next revision.

[awarzynski]

Add missing TargetSpecific flag to the definition of mcpu_EQ, remove redundant TODO

[tblah]

Looks good to me, thanks for this!

[awarzynski]

Rebase on top of main

clang/include/clang/Driver/Options.td

 def internal_debug_Group :
   OptionGroup<"<clang debug/development internal options>">,
   Group<internal_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">;
 
 class InternalDriverOpt : Group<internal_driver_Group>,
   Flags<[NoXarchOption, HelpHidden]>;
 def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>,
   Flags<[NoXarchOption, HelpHidden]>,
-  Visibility<[ClangOption, CLOption, DXCOption]>,
-  HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'">;
+  Visibility<[ClangOption, FlangOption, CLOption, DXCOption]>,
+  HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', 'cl' or 'flang'">;
 def rsp_quoting : Joined<["--"], "rsp-quoting=">, Group<internal_driver_Group>,
   Flags<[NoXarchOption, HelpHidden]>,
   Visibility<[ClangOption, CLOption, DXCOption]>,
   HelpText<"Set the rsp quoting to either 'posix', or 'windows'">;
 def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, InternalDriverOpt,
   HelpText<"Name for native GCC compiler">,
   MetaVarName<"<gcc-path>">;
 
 class InternalDebugOpt : Group<internal_debug_Group>,
   Flags<[NoXarchOption, HelpHidden]>,
   Visibility<[ClangOption, CLOption, DXCOption]>;
 def ccc_install_dir : Separate<["-"], "ccc-install-dir">, InternalDebugOpt,
   HelpText<"Simulate installation in the given directory">;
-def ccc_print_phases : Flag<["-"], "ccc-print-phases">, InternalDebugOpt,
+def ccc_print_phases : Flag<["-"], "ccc-print-phases">,
+  Flags<[NoXarchOption, HelpHidden]>, Visibility<[ClangOption, CLOption, DXCOption,
+  FlangOption]>,
   HelpText<"Dump list of actions to perform">;
 def ccc_print_bindings : Flag<["-"], "ccc-print-bindings">, InternalDebugOpt,
   HelpText<"Show bindings of tools to actions">;
 
 def ccc_arcmt_check : Flag<["-"], "ccc-arcmt-check">, InternalDriverOpt,
   HelpText<"Check for ARC migration issues that need manual handling">;
 def ccc_arcmt_modify : Flag<["-"], "ccc-arcmt-modify">, InternalDriverOpt,
   HelpText<"Apply modifications to files to conform to ARC">;
Visibility<[ClangOption, CC1Option]>,
     HelpText<"Specify name of main file output in depfile">,
     MarshallingInfoStringVector<DependencyOutputOpts<"Targets">>;
 def MV : Flag<["-"], "MV">, Group<M_Group>, Visibility<[ClangOption, CC1Option]>,
     HelpText<"Use NMake/Jom format for the depfile">,
     MarshallingInfoFlag<DependencyOutputOpts<"OutputFormat">, "DependencyOutputFormat::Make">,
     Normalizer<"makeFlagToValueNormalizer(DependencyOutputFormat::NMake)">;
 def Mach : Flag<["-"], "Mach">, Group<Link_Group>;
 def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[HelpHidden]>,
-  Visibility<[ClangOption, CC1Option, FC1Option]>;
+  Visibility<[ClangOption, CC1Option, FC1Option, FlangOption]>;
 def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[HelpHidden]>,
-  Visibility<[ClangOption, CC1Option, FC1Option]>;
+  Visibility<[ClangOption, CC1Option, FC1Option, FlangOption]>;
 def ObjCXX : Flag<["-"], "ObjC++">, Flags<[NoXarchOption]>,
   HelpText<"Treat source input files as Objective-C++ inputs">;
 def ObjC : Flag<["-"], "ObjC">, Flags<[NoXarchOption]>,
   HelpText<"Treat source input files as Objective-C inputs">;
 def O : Joined<["-"], "O">, Group<O_Group>,
-  Visibility<[ClangOption, CC1Option, FC1Option]>;
+  Visibility<[ClangOption, CC1Option, FC1Option, FlangOption]>;
 def O_flag : Flag<["-"], "O">, Visibility<[ClangOption, CC1Option, FC1Option]>,
   Alias<O>, AliasArgs<["1"]>;
 def Ofast : Joined<["-"], "Ofast">, Group<O_Group>,
   Visibility<[ClangOption, CC1Option, FlangOption]>;
 def P : Flag<["-"], "P">,
   Visibility<[ClangOption, CC1Option, FlangOption, FC1Option]>,
   Group<Preprocessor_Group>,
   HelpText<"Disable linemarker output in -E mode">,

 def U : JoinedOrSeparate<["-"], "U">, Group<Preprocessor_Group>,
   Visibility<[ClangOption, CC1Option, FlangOption, FC1Option]>,
   MetaVarName<"<macro>">, HelpText<"Undefine macro <macro>">;
 def V : JoinedOrSeparate<["-"], "V">, Flags<[NoXarchOption, Unsupported]>;
 def Wa_COMMA : CommaJoined<["-"], "Wa,">,
   HelpText<"Pass the comma separated arguments in <arg> to the assembler">,
   MetaVarName<"<arg>">;
 def Wall : Flag<["-"], "Wall">, Group<W_Group>, Flags<[HelpHidden]>,
-  Visibility<[ClangOption, CC1Option]>;
+  Visibility<[ClangOption, CC1Option, FlangOption]>;
 def WCL4 : Flag<["-"], "WCL4">, Group<W_Group>, Flags<[HelpHidden]>,
   Visibility<[ClangOption, CC1Option]>;
 def Wsystem_headers : Flag<["-"], "Wsystem-headers">, Group<W_Group>,
   Flags<[HelpHidden]>, Visibility<[ClangOption, CC1Option]>;
 def Wno_system_headers : Flag<["-"], "Wno-system-headers">, Group<W_Group>,
   Flags<[HelpHidden]>, Visibility<[ClangOption, CC1Option]>;
 def Wsystem_headers_in_module_EQ : Joined<["-"], "Wsystem-headers-in-module=">,
   Flags<[HelpHidden]>, Visibility<[ClangOption, CC1Option]>,

 defm convergent_functions : BoolFOption<"convergent-functions",
   LangOpts<"ConvergentFunctions">, DefaultFalse,
   NegFlag<SetFalse, [], [ClangOption], "Assume all functions may be convergent.">,
   PosFlag<SetTrue, [], [ClangOption, CC1Option]>>;
 
 // Common offloading options
 let Group = offload_Group in {
 def offload_arch_EQ : Joined<["--"], "offload-arch=">, Flags<[NoXarchOption]>,
+  Visibility<[ClangOption, FlangOption]>,
   HelpText<"Specify an offloading device architecture for CUDA, HIP, or OpenMP. (e.g. sm_35). "
            "If 'native' is used the compiler will detect locally installed architectures. "
            "For HIP offloading, the device architecture can be followed by target ID features "
            "delimited by a colon (e.g. gfx908:xnack+:sramecc-). May be specified more than once.">;
 def no_offload_arch_EQ : Joined<["--"], "no-offload-arch=">,
   Flags<[NoXarchOption]>,
+  Visibility<[ClangOption, FlangOption]>,
   HelpText<"Remove CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. "
            "'all' resets the list to its default value.">;
 
 def offload_new_driver : Flag<["--"], "offload-new-driver">,
   Visibility<[ClangOption, CC1Option]>, Group<f_Group>,
   MarshallingInfoFlag<LangOpts<"OffloadingNewDriver">>, HelpText<"Use the new driver for offloading compilation.">;
 def no_offload_new_driver : Flag<["--"], "no-offload-new-driver">,
   Visibility<[ClangOption, CC1Option]>, Group<f_Group>,
def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<f_Group>,
   Values<"ignore,maytrap,strict">, NormalizedValuesScope<"LangOptions">,
   NormalizedValues<["FPE_Ignore", "FPE_MayTrap", "FPE_Strict"]>,
   MarshallingInfoEnum<LangOpts<"FPExceptionMode">, "FPE_Default">;
 defm fast_math : BoolFOption<"fast-math",
   LangOpts<"FastMath">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption, CC1Option, FC1Option, FlangOption],
           "Allow aggressive, lossy floating-point optimizations",
           [cl_fast_relaxed_math.KeyPath]>,
-  NegFlag<SetFalse>>;
+  NegFlag<SetFalse, [], [ClangOption, CC1Option, FC1Option, FlangOption]>>;
 defm math_errno : BoolFOption<"math-errno",
   LangOpts<"MathErrno">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption, CC1Option],
           "Require math functions to indicate errors by setting errno">,
   NegFlag<SetFalse>>,
   ShouldParseIf<!strconcat("!", open_cl.KeyPath)>;
 def fextend_args_EQ : Joined<["-"], "fextend-arguments=">, Group<f_Group>,
   Flags<[NoArgumentUnused]>, Visibility<[ClangOption, CC1Option]>,

 
 def funsafe_math_optimizations : Flag<["-"], "funsafe-math-optimizations">,
   Group<f_Group>, Visibility<[ClangOption, CC1Option]>,
   HelpText<"Allow unsafe floating-point math optimizations which may decrease precision">,
   MarshallingInfoFlag<LangOpts<"UnsafeFPMath">>,
   ImpliedByAnyOf<[cl_unsafe_math_optimizations.KeyPath, ffast_math.KeyPath]>;
 def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">,
   Group<f_Group>;
-def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
-def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>;
+def fassociative_math : Flag<["-"], "fassociative-math">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
+def fno_associative_math : Flag<["-"], "fno-associative-math">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
 defm reciprocal_math : BoolFOption<"reciprocal-math",
   LangOpts<"AllowRecip">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption, CC1Option, FC1Option, FlangOption],
           "Allow division operations to be reassociated",
           [funsafe_math_optimizations.KeyPath]>,
   NegFlag<SetFalse>>;
 defm approx_func : BoolFOption<"approx-func", LangOpts<"ApproxFunc">, DefaultFalse,
    PosFlag<SetTrue, [], [ClangOption, CC1Option, FC1Option, FlangOption],
defm finite_math_only : BoolFOption<"finite-math-only",
   NegFlag<SetFalse>>;
 defm signed_zeros : BoolFOption<"signed-zeros",
   LangOpts<"NoSignedZero">, DefaultFalse,
   NegFlag<SetTrue, [], [ClangOption, CC1Option, FC1Option, FlangOption],
           "Allow optimizations that ignore the sign of floating point zeros",
             [cl_no_signed_zeros.KeyPath, funsafe_math_optimizations.KeyPath]>,
   PosFlag<SetFalse>>;
 def fhonor_nans : Flag<["-"], "fhonor-nans">, Group<f_Group>,
+  Visibility<[ClangOption, FlangOption]>,
   HelpText<"Specify that floating-point optimizations are not allowed that "
            "assume arguments and results are not NANs.">;
-def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Group<f_Group>;
+def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
 def fhonor_infinities : Flag<["-"], "fhonor-infinities">,
-  Group<f_Group>,
+  Group<f_Group>, Visibility<[ClangOption, FlangOption]>,
   HelpText<"Specify that floating-point optimizations are not allowed that "
            "assume arguments and results are not +-inf.">;
-def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, Group<f_Group>;
+def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">,
+  Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
 // This option was originally misspelt "infinites" [sic].
 def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>;
 def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
 def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option]>,
   MarshallingInfoFlag<LangOpts<"RoundingMath">>,
   Normalizer<"makeFlagToValueNormalizer(llvm::RoundingMode::Dynamic)">;
 def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>,
def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>,
   Alias<flax_vector_conversions_EQ>, AliasArgs<["integer"]>;
 def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>;
 def fapple_link_rtlib : Flag<["-"], "fapple-link-rtlib">, Group<f_Group>,
   HelpText<"Force linking the clang builtins runtime library">;
 def flto_EQ : Joined<["-"], "flto=">,
   Visibility<[ClangOption, CLOption, CC1Option, FC1Option, FlangOption]>,
   Group<f_Group>,
   HelpText<"Set LTO mode">, Values<"thin,full">;
-def flto_EQ_jobserver : Flag<["-"], "flto=jobserver">, Group<f_Group>,
+def flto_EQ_jobserver : Flag<["-"], "flto=jobserver">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>,
   Alias<flto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode">;
-def flto_EQ_auto : Flag<["-"], "flto=auto">, Group<f_Group>,
+def flto_EQ_auto : Flag<["-"], "flto=auto">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>,
   Alias<flto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode">;
 def flto : Flag<["-"], "flto">,
   Visibility<[ClangOption, CLOption, CC1Option, FC1Option, FlangOption]>,
   Group<f_Group>,
   Alias<flto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode">;
 defm unified_lto : BoolFOption<"unified-lto",
   CodeGenOpts<"UnifiedLTO">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption], "Use the unified LTO pipeline">,
   NegFlag<SetFalse, [], [ClangOption], "Use distinct LTO pipelines">,
   BothFlags<[], [ClangOption, CC1Option], "">>;
 def fno_lto : Flag<["-"], "fno-lto">,
-  Visibility<[ClangOption, CLOption, CC1Option]>, Group<f_Group>,
+  Visibility<[ClangOption, CLOption, DXCOption, CC1Option, FlangOption]>, Group<f_Group>,
   HelpText<"Disable LTO mode (default)">;
 def foffload_lto_EQ : Joined<["-"], "foffload-lto=">,
   Visibility<[ClangOption, CLOption]>, Group<f_Group>,
   HelpText<"Set LTO mode for offload compilation">, Values<"thin,full">;
 def foffload_lto : Flag<["-"], "foffload-lto">,
   Visibility<[ClangOption, CLOption]>, Group<f_Group>,
   Alias<foffload_lto_EQ>, AliasArgs<["full"]>, HelpText<"Enable LTO in 'full' mode for offload compilation">;
 def fno_offload_lto : Flag<["-"], "fno-offload-lto">,
defm openmp_extensions: BoolFOption<"openmp-extensions",
   NegFlag<SetFalse, [NoArgumentUnused], [ClangOption, CC1Option],
           "Disable all Clang extensions for OpenMP directives and clauses">>;
 def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>;
 def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>,
   Flags<[NoArgumentUnused, HelpHidden]>;
 def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>,
   Flags<[NoArgumentUnused, HelpHidden]>, Visibility<[ClangOption, CC1Option]>;
 def fopenmp_targets_EQ : CommaJoined<["-"], "fopenmp-targets=">,
-  Flags<[NoXarchOption]>, Visibility<[ClangOption, CC1Option]>,
+  Flags<[NoXarchOption]>, Visibility<[ClangOption, CC1Option, FlangOption]>,
   HelpText<"Specify comma-separated list of triples OpenMP offloading targets to be supported">;
 def fopenmp_relocatable_target : Flag<["-"], "fopenmp-relocatable-target">,
   Group<f_Group>, Flags<[NoArgumentUnused, HelpHidden]>,
   Visibility<[ClangOption, CC1Option]>;
 def fnoopenmp_relocatable_target : Flag<["-"], "fnoopenmp-relocatable-target">,
   Group<f_Group>, Flags<[NoArgumentUnused, HelpHidden]>,
   Visibility<[ClangOption, CC1Option]>;
 def fopenmp_simd : Flag<["-"], "fopenmp-simd">, Group<f_Group>,

 def fopenmp_cuda_teams_reduction_recs_num_EQ : Joined<["-"], "fopenmp-cuda-teams-reduction-recs-num=">, Group<f_Group>,
   Flags<[NoArgumentUnused, HelpHidden]>, Visibility<[ClangOption, CC1Option]>;
 
 //===----------------------------------------------------------------------===//
 // Shared cc1 + fc1 OpenMP Target Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [NoArgumentUnused] in {
-let Visibility = [ClangOption, CC1Option, FC1Option] in {
+let Visibility = [ClangOption, CC1Option, FC1Option, FlangOption] in {
 let Group = f_Group in {
 
 def fopenmp_target_debug : Flag<["-"], "fopenmp-target-debug">,
   HelpText<"Enable debugging in the OpenMP offloading device RTL">;
 def fno_openmp_target_debug : Flag<["-"], "fno-openmp-target-debug">;
 
 } // let Group = f_Group
 } // let Visibility = [ClangOption, CC1Option, FC1Option]
HelpText<"Report transformation analysis from optimization passes whose "
            "name matches the given POSIX regular expression">;
 def R_Joined : Joined<["-"], "R">, Group<R_Group>,
   Visibility<[ClangOption, CLOption, DXCOption]>,
   MetaVarName<"<remark>">, HelpText<"Enable the specified remark">;
 
 } // let Visibility = [ClangOption, CC1Option, FC1Option, FlangOption]
 
 let Flags = [NoArgumentUnused, HelpHidden] in {
-let Visibility = [ClangOption, CC1Option, FC1Option] in {
+let Visibility = [ClangOption, CC1Option, FC1Option, FlangOption] in {
 let Group = f_Group in {
 
 def fopenmp_target_debug_EQ : Joined<["-"], "fopenmp-target-debug=">;
 def fopenmp_assume_teams_oversubscription : Flag<["-"], "fopenmp-assume-teams-oversubscription">;
 def fopenmp_assume_threads_oversubscription : Flag<["-"], "fopenmp-assume-threads-oversubscription">;
 def fno_openmp_assume_teams_oversubscription : Flag<["-"], "fno-openmp-assume-teams-oversubscription">;
 def fno_openmp_assume_threads_oversubscription : Flag<["-"], "fno-openmp-assume-threads-oversubscription">;
 def fopenmp_assume_no_thread_state : Flag<["-"], "fopenmp-assume-no-thread-state">,
def fms_hotpatch : Flag<["-"], "fms-hotpatch">, Group<f_Group>,
   HelpText<"Ensure that all functions can be hotpatched at runtime">,
   MarshallingInfoFlag<CodeGenOpts<"HotPatch">>;
 def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option]>,
   HelpText<"Override the default ABI to return all structs on the stack">;
 def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>;
 def fpic : Flag<["-"], "fpic">, Group<f_Group>;
 def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>;
-def fpie : Flag<["-"], "fpie">, Group<f_Group>;
-def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
+def fpie : Flag<["-"], "fpie">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
+def fno_pie : Flag<["-"], "fno-pie">, Visibility<[ClangOption, FlangOption]>, Group<f_Group>;
 defm pic_data_is_text_relative : SimpleMFlag<"pic-data-is-text-relative",
      "Assume", "Don't assume", " data segments are relative to text segment">;
 def fdirect_access_external_data : Flag<["-"], "fdirect-access-external-data">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option]>,
   HelpText<"Don't use GOT indirection to reference external data symbols">;
 def fno_direct_access_external_data : Flag<["-"], "fno-direct-access-external-data">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option]>,
   HelpText<"Use GOT indirection to reference external data symbols">;
defm emit_compact_unwind_non_canonical : BoolFOption<"emit-compact-unwind-non-canonical",
   NegFlag<SetFalse>>;
 def g_Flag : Flag<["-"], "g">, Group<g_Group>,
     Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
     HelpText<"Generate source-level debug information">;
 def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>,
   Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
   HelpText<"Emit debug line number tables only">;
 def gline_directives_only : Flag<["-"], "gline-directives-only">, Group<gN_Group>,
-  Visibility<[ClangOption, CLOption, DXCOption]>,
+  Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
   HelpText<"Emit debug line info directives only">;
 def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
-def g0 : Flag<["-"], "g0">, Group<gN_Group>;
-def g1 : Flag<["-"], "g1">, Group<gN_Group>, Alias<gline_tables_only>;
-def g2 : Flag<["-"], "g2">, Group<gN_Group>;
-def g3 : Flag<["-"], "g3">, Group<gN_Group>;
+def g0 : Flag<["-"], "g0">, Group<gN_Group>, Visibility<[ClangOption, FlangOption]>;
+def g1 : Flag<["-"], "g1">, Group<gN_Group>, Visibility<[ClangOption, FlangOption]>, Alias<gline_tables_only>;
+def g2 : Flag<["-"], "g2">, Group<gN_Group>, Visibility<[ClangOption, FlangOption]>;
+def g3 : Flag<["-"], "g3">, Group<gN_Group>, Visibility<[ClangOption, FlangOption]>;
 def ggdb : Flag<["-"], "ggdb">, Group<gTune_Group>;
 def ggdb0 : Flag<["-"], "ggdb0">, Group<ggdbN_Group>;
 def ggdb1 : Flag<["-"], "ggdb1">, Group<ggdbN_Group>;
 def ggdb2 : Flag<["-"], "ggdb2">, Group<ggdbN_Group>;
 def ggdb3 : Flag<["-"], "ggdb3">, Group<ggdbN_Group>;
 def glldb : Flag<["-"], "glldb">, Group<gTune_Group>;
 def gsce : Flag<["-"], "gsce">, Group<gTune_Group>;
 def gdbx : Flag<["-"], "gdbx">, Group<gTune_Group>;

 def mappletvos_version_min_EQ : Joined<["-"], "mappletvos-version-min=">, Alias<mtvos_version_min_EQ>;
 def mtvos_simulator_version_min_EQ : Joined<["-"], "mtvos-simulator-version-min=">;
 def mappletvsimulator_version_min_EQ : Joined<["-"], "mappletvsimulator-version-min=">, Alias<mtvos_simulator_version_min_EQ>;
 def mwatchos_version_min_EQ : Joined<["-"], "mwatchos-version-min=">, Group<m_Group>;
 def mwatchos_simulator_version_min_EQ : Joined<["-"], "mwatchos-simulator-version-min=">, Group<m_Group>;
 def mwatchsimulator_version_min_EQ : Joined<["-"], "mwatchsimulator-version-min=">, Alias<mwatchos_simulator_version_min_EQ>;
 } // let Flags = [TargetSpecific]
 def march_EQ : Joined<["-"], "march=">, Group<m_Group>,
-  Flags<[TargetSpecific]>, Visibility<[ClangOption, CLOption]>,
+  Flags<[TargetSpecific]>, Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
   HelpText<"For a list of available architectures for the target use '-mcpu=help'">;
 def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[NoXarchOption]>;
 def inline_asm_EQ : Joined<["-"], "inline-asm=">, Group<m_Group>,
   Visibility<[ClangOption, CC1Option]>,
   Values<"att,intel">,
   NormalizedValuesScope<"CodeGenOptions">, NormalizedValues<["IAD_ATT", "IAD_Intel"]>,
   MarshallingInfoEnum<CodeGenOpts<"InlineAsmDialect">, "IAD_ATT">;
 def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>,

 def mconsole : Joined<["-"], "mconsole">, Group<m_Group>;
 def mwindows : Joined<["-"], "mwindows">, Group<m_Group>;
 def mdll : Joined<["-"], "mdll">, Group<m_Group>;
 def municode : Joined<["-"], "municode">, Group<m_Group>;
 def mthreads : Joined<["-"], "mthreads">, Group<m_Group>;
 def mguard_EQ : Joined<["-"], "mguard=">, Group<m_Group>,
   HelpText<"Enable or disable Control Flow Guard checks and guard tables emission">,
   Values<"none,cf,cf-nochecks">;
-def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>,
-  HelpText<"For a list of available CPUs for the target use '-mcpu=help'">;
 def mmcu_EQ : Joined<["-"], "mmcu=">, Group<m_Group>;
 def msim : Flag<["-"], "msim">, Group<m_Group>;
 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>;
 def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>;
 def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>;
 def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
 } // let Flags = [TargetSpecific]
def nogpulib : Flag<["-"], "nogpulib">, MarshallingInfoFlag<LangOpts<"NoGPULib">>,
   Visibility<[ClangOption, CC1Option]>,
   HelpText<"Do not link device library for CUDA/HIP device compilation">;
 def : Flag<["-"], "nocudalib">, Alias<nogpulib>;
 def nodefaultlibs : Flag<["-"], "nodefaultlibs">;
 def nodriverkitlib : Flag<["-"], "nodriverkitlib">;
 def nofixprebinding : Flag<["-"], "nofixprebinding">;
 def nolibc : Flag<["-"], "nolibc">;
 def nomultidefs : Flag<["-"], "nomultidefs">;
-def nopie : Flag<["-"], "nopie">;
-def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
+def nopie : Flag<["-"], "nopie">, Visibility<[ClangOption, FlangOption]>;
+def no_pie : Flag<["-"], "no-pie">, Visibility<[ClangOption, FlangOption]>, Alias<nopie>;
 def noprebind : Flag<["-"], "noprebind">;
 def noprofilelib : Flag<["-"], "noprofilelib">;
 def noseglinkedit : Flag<["-"], "noseglinkedit">;
 def nostartfiles : Flag<["-"], "nostartfiles">, Group<Link_Group>;
 def nostdinc : Flag<["-"], "nostdinc">,
   Visibility<[ClangOption, CLOption, DXCOption]>, Group<IncludePath_Group>;
 def nostdlibinc : Flag<["-"], "nostdlibinc">, Group<IncludePath_Group>;
 def nostdincxx : Flag<["-"], "nostdinc++">, Visibility<[ClangOption, CC1Option]>,

 def _entry : Flag<["--"], "entry">, Alias<e>;
 def _extdirs_EQ : Joined<["--"], "extdirs=">, Alias<fextdirs_EQ>;
 def _extdirs : Separate<["--"], "extdirs">, Alias<fextdirs_EQ>;
 def _extra_warnings : Flag<["--"], "extra-warnings">, Alias<W_Joined>;
 def _for_linker_EQ : Joined<["--"], "for-linker=">, Alias<Xlinker>;
 def _for_linker : Separate<["--"], "for-linker">, Alias<Xlinker>;
 def _force_link_EQ : Joined<["--"], "force-link=">, Alias<u>;
 def _force_link : Separate<["--"], "force-link">, Alias<u>;
-def _help_hidden : Flag<["--"], "help-hidden">,
-  HelpText<"Display help for hidden options">;
 def _imacros_EQ : Joined<["--"], "imacros=">, Alias<imacros>;
 def _include_barrier : Flag<["--"], "include-barrier">, Alias<I_>;
 def _include_directory_after_EQ : Joined<["--"], "include-directory-after=">, Alias<idirafter>;
 def _include_directory_after : Separate<["--"], "include-directory-after">, Alias<idirafter>;
 def _include_directory_EQ : Joined<["--"], "include-directory=">, Alias<I>;
 def _include_directory : Separate<["--"], "include-directory">, Alias<I>;
 def _include_prefix_EQ : Joined<["--"], "include-prefix=">, Alias<iprefix>;
 def _include_prefix : Separate<["--"], "include-prefix">, Alias<iprefix>;
def _serialize_diags : Separate<["-", "--"], "serialize-diagnostics">,
   HelpText<"Serialize compiler diagnostics to a file">;
 // We give --version different semantics from -version.
 def _version : Flag<["--"], "version">,
   Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
   HelpText<"Print version information">;
 def _signed_char : Flag<["--"], "signed-char">, Alias<fsigned_char>;
 def _std : Separate<["--"], "std">, Alias<std_EQ>;
 def _stdlib : Separate<["--"], "stdlib">, Alias<stdlib_EQ>;
-def _sysroot_EQ : Joined<["--"], "sysroot=">;
-def _sysroot : Separate<["--"], "sysroot">, Alias<_sysroot_EQ>;
 def _target_help : Flag<["--"], "target-help">;
 def _trace_includes : Flag<["--"], "trace-includes">, Alias<H>;
 def _undefine_macro_EQ : Joined<["--"], "undefine-macro=">, Alias<U>;
 def _undefine_macro : Separate<["--"], "undefine-macro">, Alias<U>;
 def _unsigned_char : Flag<["--"], "unsigned-char">, Alias<funsigned_char>;
 def _user_dependencies : Flag<["--"], "user-dependencies">, Alias<MM>;
 def _verbose : Flag<["--"], "verbose">, Alias<v>;
 def _warn__EQ : Joined<["--"], "warn-=">, Alias<W_Joined>;
 def _warn_ : Joined<["--"], "warn-">, Alias<W_Joined>;
 def _write_dependencies : Flag<["--"], "write-dependencies">, Alias<MD>;
 def _write_user_dependencies : Flag<["--"], "write-user-dependencies">, Alias<MMD>;
 
+def _help_hidden : Flag<["--"], "help-hidden">,
+  Visibility<[ClangOption, FlangOption]>,
+  HelpText<"Display help for hidden options">;
+def _sysroot_EQ : Joined<["--"], "sysroot=">, Visibility<[ClangOption, FlangOption]>;
+def _sysroot : Separate<["--"], "sysroot">, Alias<_sysroot_EQ>;
+
+//===----------------------------------------------------------------------===//
+// Target Options (clang + flang-new)
+//===----------------------------------------------------------------------===//
+let Flags = [TargetSpecific] in {
+let Visibility = [ClangOption, FlangOption] in {
+
+def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>,
+  HelpText<"For a list of available CPUs for the target use '-mcpu=help'">;
+
+} // let Vis = [Default, FlangOption]
+} // let Flags = [TargetSpecific]
+
 // Hexagon feature flags.
 let Flags = [TargetSpecific] in {
 def mieee_rnd_near : Flag<["-"], "mieee-rnd-near">,
   Group<m_hexagon_Features_Group>;
 def mv5 : Flag<["-"], "mv5">, Group<m_hexagon_Features_Group>, Alias<mcpu_EQ>,
   AliasArgs<["hexagonv5"]>;
 def mv55 : Flag<["-"], "mv55">, Group<m_hexagon_Features_Group>,
   Alias<mcpu_EQ>, AliasArgs<["hexagonv55"]>;

 def mno_vzeroupper : Flag<["-"], "mno-vzeroupper">, Group<m_x86_Features_Group>;
 } // let Flags = [TargetSpecific]
 
 // These are legacy user-facing driver-level option spellings. They are always
 // aliases for options that are spelled using the more common Unix / GNU flag
 // style of double-dash and equals-joined flags.
 def target_legacy_spelling : Separate<["-"], "target">,
                              Alias<target>,
-                             Visibility<[ClangOption, CLOption, DXCOption]>;
+                             Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>;
 
 // Special internal option to handle -Xlinker --no-demangle.
 def Z_Xlinker__no_demangle : Flag<["-"], "Z-Xlinker-no-demangle">,
     Flags<[Unsupported, NoArgumentUnused]>;
 
 // Special internal option to allow forwarding arbitrary arguments to linker.
 def Zlinker_input : Separate<["-"], "Zlinker-input">,
     Flags<[Unsupported, NoArgumentUnused]>;
 
 // Reserved library options.
 def Z_reserved_lib_stdcxx : Flag<["-"], "Z-reserved-lib-stdc++">,
     Flags<[LinkerInput, NoArgumentUnused, Unsupported]>,
     Group<reserved_lib_Group>;
 def Z_reserved_lib_cckext : Flag<["-"], "Z-reserved-lib-cckext">,
     Flags<[LinkerInput, NoArgumentUnused, Unsupported]>,
     Group<reserved_lib_Group>;
 
 // Ignored options
 multiclass BooleanFFlag<string name> {
   def f#NAME : Flag<["-"], "f"#name>;
   def fno_#NAME : Flag<["-"], "fno-"#name>;
 }
 
 multiclass FlangIgnoredDiagOpt<string name> {
-  def unsupported_warning_w#NAME : Flag<["-", "--"], "W"#name>, Group<flang_ignored_w_Group>;
+  def unsupported_warning_w#NAME : Flag<["-", "--"], "W"#name>,
+    Visibility<[FlangOption]>, Group<flang_ignored_w_Group>;
 }
 
 defm : BooleanFFlag<"keep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<f_Group>;
 
 // The default value matches BinutilsVersion in MCAsmInfo.h.
 def fbinutils_version_EQ : Joined<["-"], "fbinutils-version=">,

clang/lib/Driver/Driver.cpp

 llvm::opt::Visibility
 Driver::getOptionVisibilityMask(bool UseDriverMode) const {
   if (!UseDriverMode)
     return llvm::opt::Visibility(options::ClangOption);
   if (IsCLMode())
     return llvm::opt::Visibility(options::CLOption);
   if (IsDXCMode())
     return llvm::opt::Visibility(options::DXCOption);
   if (IsFlangMode()) {
-    // TODO: Does flang really want *all* of the clang driver options?
-    // We probably need to annotate more specifically.
-    return llvm::opt::Visibility(options::ClangOption | options::FlangOption);
+    return llvm::opt::Visibility(options::FlangOption);
   }
   return llvm::opt::Visibility(options::ClangOption);
 }
 
 const char *Driver::getExecutableForDriverMode(DriverMode Mode) {
   switch (Mode) {
   case GCCMode:
     return "clang";

clang/test/Driver/flang/flang.f90

 
 ! Check that f90 files are not treated as "previously preprocessed"
 ! ... in --driver-mode=flang.
 ! RUN: %clang --driver-mode=flang -### -E                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-E %s
 ! CHECK-E-NOT: previously preprocessed input
 ! CHECK-E-DAG: "-E"
 ! CHECK-E-DAG: "-o" "-"
 
-! RUN: %clang --driver-mode=flang -### -emit-ast           %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-AST %s
-! CHECK-EMIT-AST-DAG: "-emit-ast"
-! CHECK-EMIT-AST-DAG: "-o" "{{[^"]*}}.ast"
-
 ! RUN: %clang --driver-mode=flang -### -fsyntax-only       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-SYNTAX-ONLY %s
 ! CHECK-SYNTAX-ONLY-NOT: "-o"
 ! CHECK-SYNTAX-ONLY-DAG: "-fsyntax-only"
 
 ! RUN: %clang --driver-mode=flang -### -emit-llvm -S       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-IR %s
 ! CHECK-EMIT-LLVM-IR-DAG: "-emit-llvm"
 ! CHECK-EMIT-LLVM-IR-DAG: "-o" "{{[^"]*}}.ll"
 
 ! RUN: not %clang --driver-mode=flang -### -emit-llvm          %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-BC %s
 ! CHECK-EMIT-LLVM-BC-DAG: "-emit-llvm-bc"
 ! CHECK-EMIT-LLVM-BC-DAG: "-o" "{{[^"]*}}.bc"
 
 ! RUN: %clang --driver-mode=flang -### -S                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-S %s
 ! CHECK-S-DAG: "-S"
 ! CHECK-S-DAG: "-o" "{{[^"]*}}.s"
 
-! RUN: %clang --driver-mode=flang -### -fintegrated-as     %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-OBJ %s
+! RUN: %clang --driver-mode=flang -###                     %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-OBJ %s
 ! CHECK-EMIT-OBJ-DAG: "-emit-obj"
 ! CHECK-EMIT-OBJ-DAG: "-o" "{{[^"]*}}.o"
 
 ! Should end in the input file.
 ! ALL: "{{.*}}flang.f90"{{$}}

clang/test/Driver/flang/flang_ucase.F90

 
 ! Check that f90 files are not treated as "previously preprocessed"
 ! ... in --driver-mode=flang.
 ! RUN: %clang --driver-mode=flang -### -E                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-E %s
 ! CHECK-E-NOT: previously preprocessed input
 ! CHECK-E-DAG: "-E"
 ! CHECK-E-DAG: "-o" "-"
 
-! RUN: %clang --driver-mode=flang -### -emit-ast           %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-AST %s
-! CHECK-EMIT-AST-DAG: "-emit-ast"
-! CHECK-EMIT-AST-DAG: "-o" "{{[^"]*}}.ast"
-
 ! RUN: %clang --driver-mode=flang -### -fsyntax-only       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-SYNTAX-ONLY %s
 ! CHECK-SYNTAX-ONLY-NOT: "-o"
 ! CHECK-SYNTAX-ONLY-DAG: "-fsyntax-only"
 
 ! RUN: %clang --driver-mode=flang -### -emit-llvm -S       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-IR %s
 ! CHECK-EMIT-LLVM-IR-DAG: "-emit-llvm"
 ! CHECK-EMIT-LLVM-IR-DAG: "-o" "{{[^"]*}}.ll"
 
 ! RUN: not %clang --driver-mode=flang -### -emit-llvm          %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-BC %s
 ! CHECK-EMIT-LLVM-BC-DAG: "-emit-llvm-bc"
 ! CHECK-EMIT-LLVM-BC-DAG: "-o" "{{[^"]*}}.bc"
 
 ! RUN: %clang --driver-mode=flang -### -S                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-S %s
 ! CHECK-S-DAG: "-S"
 ! CHECK-S-DAG: "-o" "{{[^"]*}}.s"
 
-! RUN: %clang --driver-mode=flang -### -fintegrated-as     %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-OBJ %s
+! RUN: %clang --driver-mode=flang -###                     %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-OBJ %s
 ! CHECK-EMIT-OBJ-DAG: "-emit-obj"
 ! CHECK-EMIT-OBJ-DAG: "-o" "{{[^"]*}}.o"
 
 ! Should end in the input file.
 ! ALL: "{{.*}}flang_ucase.F90"{{$}}

flang/test/Driver/driver-help-hidden.f90

 
 !--------------------------
 ! FLANG DRIVER (flang-new)
 !--------------------------
 ! RUN: %flang --help-hidden 2>&1 | FileCheck %s
 ! RUN: not %flang  -help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-FLANG
 
 !----------------------------------------
 ! FLANG FRONTEND DRIVER (flang-new -fc1)
 !----------------------------------------
 ! RUN: not %flang_fc1 --help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-FLANG-FC1
 ! RUN: not %flang_fc1  -help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-FLANG-FC1
 
 ! CHECK:USAGE: flang-new
 ! CHECK-EMPTY:
+! CHECK-NEXT: DRIVER OPTIONS:
+! CHECK-NEXT:  --driver-mode=<value> Set the driver mode to either 'gcc', 'g++', 'cpp', 'cl' or 'flang'
+! CHECK-EMPTY:
 ! CHECK-NEXT:OPTIONS:
-! CHECK-NEXT: -###      Print (but do not run) the commands to run for this compilation
-! CHECK-NEXT: -cpp      Enable predefined and command line preprocessor macros
-! CHECK-NEXT: -c        Only run preprocess, compile, and assemble steps
-! CHECK-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
-! CHECK-NEXT: -emit-llvm             Use the LLVM representation for assembler and object files
-! CHECK-NEXT: -E        Only run the preprocessor
+! CHECK-NEXT: -###                    Print (but do not run) the commands to run for this compilation
+! CHECK-NEXT: -ccc-print-phases       Dump list of actions to perform
+! CHECK-NEXT: -cpp                    Enable predefined and command line preprocessor macros
+! CHECK-NEXT: -c                      Only run preprocess, compile, and assemble steps
+! CHECK-NEXT: -D <macro>=<value>      Define <macro> to <value> (or 1 if <value> omitted)
+! CHECK-NEXT: -emit-llvm              Use the LLVM representation for assembler and object files
+! CHECK-NEXT: -E                      Only run the preprocessor
 ! CHECK-NEXT: -falternative-parameter-statement
-! CHECK-NEXT: Enable the old style PARAMETER statement
-! CHECK-NEXT: -fapprox-func          Allow certain math function calls to be replaced with an approximately equivalent calculation
-! CHECK-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
-! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
-! CHECK-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
-! CHECK-NEXT: -fdefault-double-8     Set the default double precision kind to an 8 byte wide type
-! CHECK-NEXT: -fdefault-integer-8    Set the default integer and logical kind to an 8 byte wide type
-! CHECK-NEXT: -fdefault-real-8       Set the default real kind to an 8 byte wide type
-! CHECK-NEXT: -ffast-math            Allow aggressive, lossy floating-point optimizations
-! CHECK-NEXT: -ffixed-form           Process source files in fixed form
+! CHECK-NEXT:                         Enable the old style PARAMETER statement
+! CHECK-NEXT: -fapprox-func           Allow certain math function calls to be replaced with an approximately equivalent calculation
+! CHECK-NEXT: -fbackslash             Specify that backslash in string introduces an escape character
+! CHECK-NEXT: -fcolor-diagnostics     Enable colors in diagnostics
+! CHECK-NEXT: -fconvert=<value>       Set endian conversion of data for unformatted files
+! CHECK-NEXT: -fdefault-double-8      Set the default double precision kind to an 8 byte wide type
+! CHECK-NEXT: -fdefault-integer-8     Set the default integer and logical kind to an 8 byte wide type
+! CHECK-NEXT: -fdefault-real-8        Set the default real kind to an 8 byte wide type
+! CHECK-NEXT: -ffast-math             Allow aggressive, lossy floating-point optimizations
+! CHECK-NEXT: -ffixed-form            Process source files in fixed form
 ! CHECK-NEXT: -ffixed-line-length=<value>
-! CHECK-NEXT: Use <value> as character line width in fixed mode
-! CHECK-NEXT: -ffp-contract=<value> Form fused FP ops (e.g. FMAs)
-! CHECK-NEXT: -ffree-form            Process source files in free form
-! CHECK-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
+! CHECK-NEXT:                         Use <value> as character line width in fixed mode
+! CHECK-NEXT: -ffp-contract=<value>   Form fused FP ops (e.g. FMAs)
+! CHECK-NEXT: -ffree-form             Process source files in free form
+! CHECK-NEXT: -fhonor-infinities      Specify that floating-point optimizations are not allowed that assume arguments and results are not +-inf.
+! CHECK-NEXT: -fhonor-nans            Specify that floating-point optimizations are not allowed that assume arguments and results are not NANs.
+! CHECK-NEXT: -fimplicit-none         No implicit typing allowed unless overridden by IMPLICIT statements
 ! CHECK-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! CHECK-NEXT: -fintrinsic-modules-path <dir>
-! CHECK-NEXT:                        Specify where to find the compiled intrinsic modules
+! CHECK-NEXT:                         Specify where to find the compiled intrinsic modules
 ! CHECK-NEXT: -flang-experimental-hlfir
-! CHECK-NEXT:                        Use HLFIR lowering (experimental)
+! CHECK-NEXT:                         Use HLFIR lowering (experimental)
 ! CHECK-NEXT: -flang-experimental-polymorphism
-! CHECK-NEXT:                        Enable Fortran 2003 polymorphism (experimental)
-! CHECK-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
+! CHECK-NEXT:                         Enable Fortran 2003 polymorphism (experimental)
+! CHECK-NEXT: -flarge-sizes           Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! CHECK-NEXT: -flogical-abbreviations Enable logical abbreviations
-! CHECK-NEXT: -flto=<value> Set LTO mode
-! CHECK-NEXT: -flto Enable LTO in 'full' mode
-! CHECK-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
+! CHECK-NEXT: -flto=auto              Enable LTO in 'full' mode
+! CHECK-NEXT: -flto=jobserver         Enable LTO in 'full' mode
+! CHECK-NEXT: -flto=<value>           Set LTO mode
+! CHECK-NEXT: -flto                   Enable LTO in 'full' mode
+! CHECK-NEXT: -fno-automatic          Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! CHECK-NEXT: -fno-color-diagnostics  Disable colors in diagnostics
-! CHECK-NEXT: -fno-integrated-as     Disable the integrated assembler
+! CHECK-NEXT: -fno-integrated-as      Disable the integrated assembler
+! CHECK-NEXT: -fno-lto                Disable LTO mode (default)
 ! CHECK-NEXT: -fno-ppc-native-vector-element-order
-! CHECK-NEXT:                        Specifies PowerPC non-native vector element order
-! CHECK-NEXT: -fno-signed-zeros      Allow optimizations that ignore the sign of floating point zeros
-! CHECK-NEXT: -fno-stack-arrays      Allocate array temporaries on the heap (default)
+! CHECK-NEXT:                         Specifies PowerPC non-native vector element order
+! CHECK-NEXT: -fno-signed-zeros       Allow optimizations that ignore the sign of floating point zeros
+! CHECK-NEXT: -fno-stack-arrays       Allocate array temporaries on the heap (default)
 ! CHECK-NEXT: -fno-version-loops-for-stride
-! CHECK-NEXT:                        Do not create unit-strided loops (default)
-! CHECK-NEXT: -fopenacc              Enable OpenACC
+! CHECK-NEXT:                         Do not create unit-strided loops (default)
+! CHECK-NEXT: -fopenacc               Enable OpenACC
+! CHECK-NEXT: -fopenmp-assume-no-nested-parallelism
+! CHECK-NEXT:                         Assert no nested parallel regions in the GPU
+! CHECK-NEXT: -fopenmp-assume-no-thread-state
+! CHECK-NEXT:                         Assert no thread in a parallel region modifies an ICV
+! CHECK-NEXT: -fopenmp-target-debug   Enable debugging in the OpenMP offloading device RTL
+! CHECK-NEXT: -fopenmp-targets=<value>
+! CHECK-NEXT:                         Specify comma-separated list of triples OpenMP offloading targets to be supported
 ! CHECK-NEXT: -fopenmp-version=<value>
-! CHECK-NEXT:                        Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
-! CHECK-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
+! CHECK-NEXT:                         Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
+! CHECK-NEXT: -fopenmp                Parse OpenMP pragmas and generate parallel code.
 ! CHECK-NEXT: -foptimization-record-file=<file>
-! CHECK-NEXT:                        Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.
+! CHECK-NEXT:                         Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.
 ! CHECK-NEXT: -foptimization-record-passes=<regex>
-! CHECK-NEXT:                        Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)
+! CHECK-NEXT:                         Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)
 ! CHECK-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
 ! CHECK-NEXT: -fppc-native-vector-element-order
-! CHECK-NEXT:                        Specifies PowerPC native vector element order
-! CHECK-NEXT: -freciprocal-math      Allow division operations to be reassociated
+! CHECK-NEXT:                         Specifies PowerPC native vector element order (default)
+! CHECK-NEXT: -freciprocal-math       Allow division operations to be reassociated
 ! CHECK-NEXT: -fsave-optimization-record=<format>
-! CHECK-NEXT:                        Generate an optimization record file in a specific format
+! CHECK-NEXT:                         Generate an optimization record file in a specific format
 ! CHECK-NEXT: -fsave-optimization-record
-! CHECK-NEXT:                        Generate a YAML optimization record file
-! CHECK-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
-! CHECK-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
-! CHECK-NEXT: -funderscoring         Appends one trailing underscore to external names
+! CHECK-NEXT:                         Generate a YAML optimization record file
+! CHECK-NEXT: -fstack-arrays          Attempt to allocate array temporaries on the stack, no matter their size
+! CHECK-NEXT: -fsyntax-only           Run the preprocessor, parser and semantic analysis stages
+! CHECK-NEXT: -funderscoring          Appends one trailing underscore to external names
 ! CHECK-NEXT: -fversion-loops-for-stride
-! CHECK-NEXT:                        Create unit-strided versions of loops
-! CHECK-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
-! CHECK-NEXT: -gline-tables-only     Emit debug line number tables only
-! CHECK-NEXT: -g                     Generate source-level debug information
-! CHECK-NEXT: -help     Display available options
-! CHECK-NEXT: -I <dir>               Add directory to the end of the list of include search paths
-! CHECK-NEXT: -mllvm=<arg>           Alias for -mllvm
-! CHECK-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
-! CHECK-NEXT: -mmlir <value>         Additional arguments to forward to MLIR's option processing
-! CHECK-NEXT: -module-dir <dir>      Put MODULE files in <dir>
-! CHECK-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
+! CHECK-NEXT:                         Create unit-strided versions of loops
+! CHECK-NEXT: -fxor-operator          Enable .XOR. as a synonym of .NEQV.
+! CHECK-NEXT: -gline-directives-only  Emit debug line info directives only
+! CHECK-NEXT: -gline-tables-only      Emit debug line number tables only
+! CHECK-NEXT: -g                      Generate source-level debug information
+! CHECK-NEXT: --help-hidden           Display help for hidden options
+! CHECK-NEXT: -help                   Display available options
+! CHECK-NEXT: -I <dir>                Add directory to the end of the list of include search paths
+! CHECK-NEXT: -march=<value>          For a list of available architectures for the target use '-mcpu=help'
+! CHECK-NEXT: -mcpu=<value>           For a list of available CPUs for the target use '-mcpu=help'
+! CHECK-NEXT: -mllvm=<arg>            Alias for -mllvm
+! CHECK-NEXT: -mllvm <value>          Additional arguments to forward to LLVM's option processing
+! CHECK-NEXT: -mmlir <value>          Additional arguments to forward to MLIR's option processing
+! CHECK-NEXT: -module-dir <dir>       Put MODULE files in <dir>
+! CHECK-NEXT: --no-offload-arch=<value>
+! CHECK-NEXT:                         Remove CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. 'all' resets the list to its default value.
+! CHECK-NEXT: -nocpp                  Disable predefined and command line preprocessor macros
+! CHECK-NEXT: --offload-arch=<value>  Specify an offloading device architecture for CUDA, HIP, or OpenMP. (e.g. sm_35). If 'native' is used the compiler will detect locally installed architectures. For HIP offloading, the device architecture can be followed by target ID features delimited by a colon (e.g. gfx908:xnack+:sramecc-). May be specified more than once.
 ! CHECK-NEXT: --offload-device-only   Only compile for the offloading device.
 ! CHECK-NEXT: --offload-host-device   Compile for both the offloading host and device (default).
 ! CHECK-NEXT: --offload-host-only     Only compile for the offloading host.
-! CHECK-NEXT: -o <file> Write output to <file>
-! CHECK-NEXT: -pedantic              Warn on language extensions
+! CHECK-NEXT: -o <file>               Write output to <file>
+! CHECK-NEXT: -pedantic               Warn on language extensions
 ! CHECK-NEXT: -print-effective-triple Print the effective target triple
 ! CHECK-NEXT: -print-target-triple    Print the normalized target triple
-! CHECK-NEXT: -P                     Disable linemarker output in -E mode
+! CHECK-NEXT: -P                      Disable linemarker output in -E mode
 ! CHECK-NEXT: -Rpass-analysis=<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression
 ! CHECK-NEXT: -Rpass-missed=<value>   Report missed transformations by optimization passes whose name matches the given POSIX regular expression
 ! CHECK-NEXT: -Rpass=<value>          Report transformations performed by optimization passes whose name matches the given POSIX regular expression
 ! CHECK-NEXT: -R<remark>              Enable the specified remark
-! CHECK-NEXT: -save-temps=<value>    Save intermediate compilation results.
-! CHECK-NEXT: -save-temps            Save intermediate compilation results
-! CHECK-NEXT: -std=<value>           Language standard to compile for
-! CHECK-NEXT: -S                     Only run preprocess and compilation steps
+! CHECK-NEXT: -save-temps=<value>     Save intermediate compilation results.
+! CHECK-NEXT: -save-temps             Save intermediate compilation results
+! CHECK-NEXT: -std=<value>            Language standard to compile for
+! CHECK-NEXT: -S                      Only run preprocess and compilation steps
 ! CHECK-NEXT: --target=<value>        Generate code for the given target
-! CHECK-NEXT: -U <macro>             Undefine macro <macro>
-! CHECK-NEXT: --version Print version information
-! CHECK-NEXT: -W<warning>            Enable the specified warning
-! CHECK-NEXT: -Xflang <arg>          Pass <arg> to the flang compiler
+! CHECK-NEXT: -U <macro>              Undefine macro <macro>
+! CHECK-NEXT: --version               Print version information
+! CHECK-NEXT: -W<warning>             Enable the specified warning
+! CHECK-NEXT: -Xflang <arg>           Pass <arg> to the flang compiler
+! CHECK-NEXT: -x <language>           Treat subsequent input files as having type <language>
 
 ! ERROR-FLANG: error: unknown argument '-help-hidden'; did you mean '--help-hidden'?
 
 ! Frontend driver -help-hidden is not supported
 ! ERROR-FLANG-FC1: error: unknown argument: '{{.*}}'

flang/test/Driver/driver-help.f90

 
 !--------------------------
 ! FLANG DRIVER (flang)
 !--------------------------
 ! RUN: %flang -help 2>&1 | FileCheck %s --check-prefix=HELP
 ! RUN: not %flang -helps 2>&1 | FileCheck %s --check-prefix=ERROR
 
 !----------------------------------------
 ! FLANG FRONTEND DRIVER (flang -fc1)
 !----------------------------------------
 ! RUN: %flang_fc1 -help 2>&1 | FileCheck %s --check-prefix=HELP-FC1
 ! RUN: not %flang_fc1 -helps 2>&1 | FileCheck %s --check-prefix=ERROR
 
 ! HELP:USAGE: flang
 ! HELP-EMPTY:
 ! HELP-NEXT:OPTIONS:
-! HELP-NEXT: -###                   Print (but do not run) the commands to run for this compilation
-! HELP-NEXT: -cpp                   Enable predefined and command line preprocessor macros
-! HELP-NEXT: -c                     Only run preprocess, compile, and assemble steps
-! HELP-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
-! HELP-NEXT: -emit-llvm             Use the LLVM representation for assembler and object files
-! HELP-NEXT: -E                     Only run the preprocessor
+! HELP-NEXT: -###                    Print (but do not run) the commands to run for this compilation
+! HELP-NEXT: -cpp                    Enable predefined and command line preprocessor macros
+! HELP-NEXT: -c                      Only run preprocess, compile, and assemble steps
+! HELP-NEXT: -D <macro>=<value>      Define <macro> to <value> (or 1 if <value> omitted)
+! HELP-NEXT: -emit-llvm              Use the LLVM representation for assembler and object files
+! HELP-NEXT: -E                      Only run the preprocessor
 ! HELP-NEXT: -falternative-parameter-statement
-! HELP-NEXT: Enable the old style PARAMETER statement
-! HELP-NEXT: -fapprox-func          Allow certain math function calls to be replaced with an approximately equivalent calculation
-! HELP-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
-! HELP-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
-! HELP-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
-! HELP-NEXT: -fdefault-double-8     Set the default double precision kind to an 8 byte wide type
-! HELP-NEXT: -fdefault-integer-8    Set the default integer and logical kind to an 8 byte wide type
-! HELP-NEXT: -fdefault-real-8       Set the default real kind to an 8 byte wide type
-! HELP-NEXT: -ffast-math            Allow aggressive, lossy floating-point optimizations
-! HELP-NEXT: -ffixed-form           Process source files in fixed form
+! HELP-NEXT:                         Enable the old style PARAMETER statement
+! HELP-NEXT: -fapprox-func           Allow certain math function calls to be replaced with an approximately equivalent calculation
+! HELP-NEXT: -fbackslash             Specify that backslash in string introduces an escape character
+! HELP-NEXT: -fcolor-diagnostics     Enable colors in diagnostics
+! HELP-NEXT: -fconvert=<value>       Set endian conversion of data for unformatted files
+! HELP-NEXT: -fdefault-double-8      Set the default double precision kind to an 8 byte wide type
+! HELP-NEXT: -fdefault-integer-8     Set the default integer and logical kind to an 8 byte wide type
+! HELP-NEXT: -fdefault-real-8        Set the default real kind to an 8 byte wide type
+! HELP-NEXT: -ffast-math             Allow aggressive, lossy floating-point optimizations
+! HELP-NEXT: -ffixed-form            Process source files in fixed form
 ! HELP-NEXT: -ffixed-line-length=<value>
-! HELP-NEXT: Use <value> as character line width in fixed mode
-! HELP-NEXT: -ffp-contract=<value> Form fused FP ops (e.g. FMAs)
-! HELP-NEXT: -ffree-form            Process source files in free form
-! HELP-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
+! HELP-NEXT:                         Use <value> as character line width in fixed mode
+! HELP-NEXT: -ffp-contract=<value>   Form fused FP ops (e.g. FMAs)
+! HELP-NEXT: -ffree-form             Process source files in free form
+! HELP-NEXT: -fhonor-infinities      Specify that floating-point optimizations are not allowed that assume arguments and results are not +-inf.
+! HELP-NEXT: -fhonor-nans            Specify that floating-point optimizations are not allowed that assume arguments and results are not NANs.
+! HELP-NEXT: -fimplicit-none         No implicit typing allowed unless overridden by IMPLICIT statements
 ! HELP-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! HELP-NEXT: -fintrinsic-modules-path <dir>
-! HELP-NEXT:                        Specify where to find the compiled intrinsic modules
-! HELP-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
+! HELP-NEXT:                         Specify where to find the compiled intrinsic modules
+! HELP-NEXT: -flarge-sizes           Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-NEXT: -flogical-abbreviations Enable logical abbreviations
-! HELP-NEXT: -flto=<value> Set LTO mode
-! HELP-NEXT: -flto Enable LTO in 'full' mode
-! HELP-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
+! HELP-NEXT: -flto=auto              Enable LTO in 'full' mode
+! HELP-NEXT: -flto=jobserver         Enable LTO in 'full' mode
+! HELP-NEXT: -flto=<value>           Set LTO mode
+! HELP-NEXT: -flto                   Enable LTO in 'full' mode
+! HELP-NEXT: -fno-automatic          Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! HELP-NEXT: -fno-color-diagnostics  Disable colors in diagnostics
 ! HELP-NEXT: -fno-integrated-as      Disable the integrated assembler
+! HELP-NEXT: -fno-lto                Disable LTO mode (default)
 ! HELP-NEXT: -fno-ppc-native-vector-element-order
-! HELP-NEXT:                        Specifies PowerPC non-native vector element order
-! HELP-NEXT: -fno-signed-zeros      Allow optimizations that ignore the sign of floating point zeros
-! HELP-NEXT: -fno-stack-arrays      Allocate array temporaries on the heap (default)
+! HELP-NEXT:                         Specifies PowerPC non-native vector element order
+! HELP-NEXT: -fno-signed-zeros       Allow optimizations that ignore the sign of floating point zeros
+! HELP-NEXT: -fno-stack-arrays       Allocate array temporaries on the heap (default)
 ! HELP-NEXT: -fno-version-loops-for-stride
-! HELP-NEXT:                        Do not create unit-strided loops (default)
-! HELP-NEXT: -fopenacc              Enable OpenACC
+! HELP-NEXT:                         Do not create unit-strided loops (default)
+! HELP-NEXT: -fopenacc               Enable OpenACC
+! HELP-NEXT: -fopenmp-target-debug   Enable debugging in the OpenMP offloading device RTL
+! HELP-NEXT: -fopenmp-targets=<value>
+! HELP-NEXT:                         Specify comma-separated list of triples OpenMP offloading targets to be supported
 ! HELP-NEXT: -fopenmp-version=<value>
-! HELP-NEXT:                        Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
-! HELP-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
+! HELP-NEXT:                         Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
+! HELP-NEXT: -fopenmp                Parse OpenMP pragmas and generate parallel code.
 ! HELP-NEXT: -foptimization-record-file=<file>
-! HELP-NEXT:                        Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.
+! HELP-NEXT:                         Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.
 ! HELP-NEXT: -foptimization-record-passes=<regex>
-! HELP-NEXT:                        Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)
+! HELP-NEXT:                         Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)
 ! HELP-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
 ! HELP-NEXT: -fppc-native-vector-element-order
-! HELP-NEXT:                        Specifies PowerPC native vector element order
-! HELP-NEXT: -freciprocal-math      Allow division operations to be reassociated
+! HELP-NEXT:                         Specifies PowerPC native vector element order (default)
+! HELP-NEXT: -freciprocal-math       Allow division operations to be reassociated
 ! HELP-NEXT: -fsave-optimization-record=<format>
-! HELP-NEXT:                        Generate an optimization record file in a specific format
+! HELP-NEXT:                         Generate an optimization record file in a specific format
 ! HELP-NEXT: -fsave-optimization-record
-! HELP-NEXT:                        Generate a YAML optimization record file
-! HELP-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
-! HELP-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
-! HELP-NEXT: -funderscoring         Appends one trailing underscore to external names
+! HELP-NEXT:                         Generate a YAML optimization record file
+! HELP-NEXT: -fstack-arrays          Attempt to allocate array temporaries on the stack, no matter their size
+! HELP-NEXT: -fsyntax-only           Run the preprocessor, parser and semantic analysis stages
+! HELP-NEXT: -funderscoring          Appends one trailing underscore to external names
 ! HELP-NEXT: -fversion-loops-for-stride
-! HELP-NEXT:                        Create unit-strided versions of loops
-! HELP-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
-! HELP-NEXT: -gline-tables-only     Emit debug line number tables only
-! HELP-NEXT: -g                     Generate source-level debug information
-! HELP-NEXT: -help                  Display available options
-! HELP-NEXT: -I <dir>               Add directory to the end of the list of include search paths
-! HELP-NEXT: -mllvm=<arg>           Alias for -mllvm
-! HELP-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
-! HELP-NEXT: -mmlir <value>         Additional arguments to forward to MLIR's option processing
-! HELP-NEXT: -module-dir <dir>      Put MODULE files in <dir>
-! HELP-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
+! HELP-NEXT:                         Create unit-strided versions of loops
+! HELP-NEXT: -fxor-operator          Enable .XOR. as a synonym of .NEQV.
+! HELP-NEXT: -gline-directives-only  Emit debug line info directives only
+! HELP-NEXT: -gline-tables-only      Emit debug line number tables only
+! HELP-NEXT: -g                      Generate source-level debug information
+! HELP-NEXT: --help-hidden           Display help for hidden options
+! HELP-NEXT: -help                   Display available options
+! HELP-NEXT: -I <dir>                Add directory to the end of the list of include search paths
+! HELP-NEXT: -march=<value>          For a list of available architectures for the target use '-mcpu=help'
+! HELP-NEXT: -mcpu=<value>           For a list of available CPUs for the target use '-mcpu=help'
+! HELP-NEXT: -mllvm=<arg>            Alias for -mllvm
+! HELP-NEXT: -mllvm <value>          Additional arguments to forward to LLVM's option processing
+! HELP-NEXT: -mmlir <value>          Additional arguments to forward to MLIR's option processing
+! HELP-NEXT: -module-dir <dir>       Put MODULE files in <dir>
+! HELP-NEXT: --no-offload-arch=<value>
+! HELP-NEXT:                         Remove CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. 'all' resets the list to its default value.
+! HELP-NEXT: -nocpp                  Disable predefined and command line preprocessor macros
+! HELP-NEXT: --offload-arch=<value>  Specify an offloading device architecture for CUDA, HIP, or OpenMP. (e.g. sm_35). If 'native' is used the compiler will detect locally installed architectures. For HIP offloading, the device architecture can be followed by target ID features delimited by a colon (e.g. gfx908:xnack+:sramecc-). May be specified more than once.
 ! HELP-NEXT: --offload-device-only   Only compile for the offloading device.
 ! HELP-NEXT: --offload-host-device   Compile for both the offloading host and device (default).
 ! HELP-NEXT: --offload-host-only     Only compile for the offloading host.
-! HELP-NEXT: -o <file>              Write output to <file>
-! HELP-NEXT: -pedantic              Warn on language extensions
+! HELP-NEXT: -o <file>               Write output to <file>
+! HELP-NEXT: -pedantic               Warn on language extensions
 ! HELP-NEXT: -print-effective-triple Print the effective target triple
 ! HELP-NEXT: -print-target-triple    Print the normalized target triple
-! HELP-NEXT: -P                     Disable linemarker output in -E mode
+! HELP-NEXT: -P                      Disable linemarker output in -E mode
 ! HELP-NEXT: -Rpass-analysis=<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression
 ! HELP-NEXT: -Rpass-missed=<value>   Report missed transformations by optimization passes whose name matches the given POSIX regular expression
 ! HELP-NEXT: -Rpass=<value>          Report transformations performed by optimization passes whose name matches the given POSIX regular expression
 ! HELP-NEXT: -R<remark>              Enable the specified remark
-! HELP-NEXT: -save-temps=<value>    Save intermediate compilation results.
-! HELP-NEXT: -save-temps            Save intermediate compilation results
-! HELP-NEXT: -std=<value>           Language standard to compile for
-! HELP-NEXT: -S                     Only run preprocess and compilation steps
-! HELP-NEXT: --target=<value>       Generate code for the given target
-! HELP-NEXT: -U <macro>             Undefine macro <macro>
-! HELP-NEXT: --version              Print version information
-! HELP-NEXT: -W<warning>            Enable the specified warning
-! HELP-NEXT: -Xflang <arg>          Pass <arg> to the flang compiler
+! HELP-NEXT: -save-temps=<value>     Save intermediate compilation results.
+! HELP-NEXT: -save-temps             Save intermediate compilation results
+! HELP-NEXT: -std=<value>            Language standard to compile for
+! HELP-NEXT: -S                      Only run preprocess and compilation steps
+! HELP-NEXT: --target=<value>        Generate code for the given target
+! HELP-NEXT: -U <macro>              Undefine macro <macro>
+! HELP-NEXT: --version               Print version information
+! HELP-NEXT: -W<warning>             Enable the specified warning
+! HELP-NEXT: -Xflang <arg>           Pass <arg> to the flang compiler
+! HELP-NEXT: -x <language>           Treat subsequent input files as having type <language>
+
 
 ! HELP-FC1:USAGE: flang
 ! HELP-FC1-EMPTY:
 ! HELP-FC1-NEXT:OPTIONS:
-! HELP-FC1-NEXT: -cpp                   Enable predefined and command line preprocessor macros
-! HELP-FC1-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
-! HELP-FC1-NEXT: -emit-fir              Build the parse tree, then lower it to FIR
-! HELP-FC1-NEXT: -emit-hlfir            Build the parse tree, then lower it to HLFIR
-! HELP-FC1-NEXT: -emit-llvm-bc          Build ASTs then convert to LLVM, emit .bc file
-! HELP-FC1-NEXT: -emit-llvm Use the LLVM representation for assembler and object files
-! HELP-FC1-NEXT: -emit-obj Emit native object files
-! HELP-FC1-NEXT: -E                     Only run the preprocessor
+! HELP-FC1-NEXT: -cpp                    Enable predefined and command line preprocessor macros
+! HELP-FC1-NEXT: -D <macro>=<value>      Define <macro> to <value> (or 1 if <value> omitted)
+! HELP-FC1-NEXT: -emit-fir               Build the parse tree, then lower it to FIR
+! HELP-FC1-NEXT: -emit-hlfir             Build the parse tree, then lower it to HLFIR
+! HELP-FC1-NEXT: -emit-llvm-bc           Build ASTs then convert to LLVM, emit .bc file
+! HELP-FC1-NEXT: -emit-llvm              Use the LLVM representation for assembler and object files
+! HELP-FC1-NEXT: -emit-obj               Emit native object files
+! HELP-FC1-NEXT: -E                      Only run the preprocessor
 ! HELP-FC1-NEXT: -falternative-parameter-statement
-! HELP-FC1-NEXT: Enable the old style PARAMETER statement
-! HELP-FC1-NEXT: -fapprox-func          Allow certain math function calls to be replaced with an approximately equivalent calculation
-! HELP-FC1-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
+! HELP-FC1-NEXT:                         Enable the old style PARAMETER statement
+! HELP-FC1-NEXT: -fapprox-func           Allow certain math function calls to be replaced with an approximately equivalent calculation
+! HELP-FC1-NEXT: -fbackslash             Specify that backslash in string introduces an escape character
 ! HELP-FC1-NEXT: -fcolor-diagnostics     Enable colors in diagnostics
-! HELP-FC1-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
-! HELP-FC1-NEXT: -fdebug-dump-all       Dump symbols and the parse tree after the semantic checks
+! HELP-FC1-NEXT: -fconvert=<value>       Set endian conversion of data for unformatted files
+! HELP-FC1-NEXT: -fdebug-dump-all        Dump symbols and the parse tree after the semantic checks
 ! HELP-FC1-NEXT: -fdebug-dump-parse-tree-no-sema
-! HELP-FC1-NEXT:                        Dump the parse tree (skips the semantic checks)
+! HELP-FC1-NEXT:                         Dump the parse tree (skips the semantic checks)
 ! HELP-FC1-NEXT: -fdebug-dump-parse-tree Dump the parse tree
 ! HELP-FC1-NEXT: -fdebug-dump-parsing-log
-! HELP-FC1-NEXT:                   Run instrumented parse and dump the parsing log
+! HELP-FC1-NEXT:                         Run instrumented parse and dump the parsing log
 ! HELP-FC1-NEXT: -fdebug-dump-pft        Dump the pre-fir parse tree
 ! HELP-FC1-NEXT: -fdebug-dump-provenance Dump provenance
 ! HELP-FC1-NEXT: -fdebug-dump-symbols    Dump symbols after the semantic analysis
 ! HELP-FC1-NEXT: -fdebug-measure-parse-tree
 ! HELP-FC1-NEXT:                         Measure the parse tree
 ! HELP-FC1-NEXT: -fdebug-module-writer   Enable debug messages while writing module files
-! HELP-FC1-NEXT: -fdebug-pass-manager    Prints debug information for the new pass manage
+! HELP-FC1-NEXT: -fdebug-pass-manager    Prints debug information for the new pass manager
 ! HELP-FC1-NEXT: -fdebug-pre-fir-tree    Dump the pre-FIR tree
 ! HELP-FC1-NEXT: -fdebug-unparse-no-sema Unparse and stop (skips the semantic checks)
 ! HELP-FC1-NEXT: -fdebug-unparse-with-symbols
-! HELP-FC1-NEXT:                        Unparse and stop.
-! HELP-FC1-NEXT: -fdebug-unparse        Unparse and stop.
-! HELP-FC1-NEXT: -fdefault-double-8  Set the default double precision kind to an 8 byte wide type
-! HELP-FC1-NEXT: -fdefault-integer-8 Set the default integer and logical kind to an 8 byte wide type
-! HELP-FC1-NEXT: -fdefault-real-8    Set the default real kind to an 8 byte wide type
+! HELP-FC1-NEXT:                         Unparse and stop.
+! HELP-FC1-NEXT: -fdebug-unparse         Unparse and stop.
+! HELP-FC1-NEXT: -fdefault-double-8      Set the default double precision kind to an 8 byte wide type
+! HELP-FC1-NEXT: -fdefault-integer-8     Set the default integer and logical kind to an 8 byte wide type
+! HELP-FC1-NEXT: -fdefault-real-8        Set the default real kind to an 8 byte wide type
 ! HELP-FC1-NEXT: -fembed-offload-object=<value>
-! HELP-FC1-NEXT:                        Embed Offloading device-side binary into host object file as a section.
-! HELP-FC1-NEXT: -ffast-math            Allow aggressive, lossy floating-point optimizations
-! HELP-FC1-NEXT: -ffixed-form           Process source files in fixed form
+! HELP-FC1-NEXT:                         Embed Offloading device-side binary into host object file as a section.
+! HELP-FC1-NEXT: -ffast-math             Allow aggressive, lossy floating-point optimizations
+! HELP-FC1-NEXT: -ffixed-form            Process source files in fixed form
 ! HELP-FC1-NEXT: -ffixed-line-length=<value>
-! HELP-FC1-NEXT: Use <value> as character line width in fixed mode
-! HELP-FC1-NEXT: -ffp-contract=<value> Form fused FP ops (e.g. FMAs)
-! HELP-FC1-NEXT: -ffree-form            Process source files in free form
+! HELP-FC1-NEXT:                         Use <value> as character line width in fixed mode
+! HELP-FC1-NEXT: -ffp-contract=<value>   Form fused FP ops (e.g. FMAs)
+! HELP-FC1-NEXT: -ffree-form             Process source files in free form
 ! HELP-FC1-NEXT: -fget-definition <value> <value> <value>
-! HELP-FC1-NEXT:                        Get the symbol definition from <line> <start-column> <end-column>
+! HELP-FC1-NEXT:                         Get the symbol definition from <line> <start-column> <end-column>
 ! HELP-FC1-NEXT: -fget-symbols-sources   Dump symbols and their source code locations
-! HELP-FC1-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
+! HELP-FC1-NEXT: -fimplicit-none         No implicit typing allowed unless overridden by IMPLICIT statements
 ! HELP-FC1-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! HELP-FC1-NEXT: -fintrinsic-modules-path <dir>
-! HELP-FC1-NEXT:                        Specify where to find the compiled intrinsic modules
-! HELP-FC1-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
+! HELP-FC1-NEXT:                         Specify where to find the compiled intrinsic modules
+! HELP-FC1-NEXT: -flarge-sizes           Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-FC1-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-FC1-NEXT: -flto=<value>           Set LTO mode
 ! HELP-FC1-NEXT: -flto                   Enable LTO in 'full' mode
 ! HELP-FC1-NEXT: -fno-analyzed-objects-for-unparse
-! HELP-FC1-NEXT:                        Do not use the analyzed objects when unparsing
-! HELP-FC1-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
+! HELP-FC1-NEXT:                         Do not use the analyzed objects when unparsing
+! HELP-FC1-NEXT: -fno-automatic          Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! HELP-FC1-NEXT: -fno-debug-pass-manager Disables debug printing for the new pass manager
 ! HELP-FC1-NEXT: -fno-ppc-native-vector-element-order
-! HELP-FC1-NEXT:                        Specifies PowerPC non-native vector element order
-! HELP-FC1-NEXT: -fno-reformat          Dump the cooked character stream in -E mode
-! HELP-FC1-NEXT: -fno-signed-zeros      Allow optimizations that ignore the sign of floating point zeros
-! HELP-FC1-NEXT: -fno-stack-arrays      Allocate array temporaries on the heap (default)
+! HELP-FC1-NEXT:                         Specifies PowerPC non-native vector element order
+! HELP-FC1-NEXT: -fno-reformat           Dump the cooked character stream in -E mode
+! HELP-FC1-NEXT: -fno-signed-zeros       Allow optimizations that ignore the sign of floating point zeros
+! HELP-FC1-NEXT: -fno-stack-arrays       Allocate array temporaries on the heap (default)
 ! HELP-FC1-NEXT: -fno-version-loops-for-stride
-! HELP-FC1-NEXT:                        Do not create unit-strided loops (default)
-! HELP-FC1-NEXT: -fopenacc              Enable OpenACC
-! HELP-FC1-NEXT: -fopenmp-host-ir-file-path <value> 
-! HELP-FC1-NEXT:                        Path to the IR file produced by the frontend for the host.
+! HELP-FC1-NEXT:                         Do not create unit-strided loops (default)
+! HELP-FC1-NEXT: -fopenacc               Enable OpenACC
+! HELP-FC1-NEXT: -fopenmp-host-ir-file-path <value>
+! HELP-FC1-NEXT:                         Path to the IR file produced by the frontend for the host.
 ! HELP-FC1-NEXT: -fopenmp-is-target-device
-! HELP-FC1-NEXT:                        Generate code only for an OpenMP target device.
-! HELP-FC1-NEXT: -fopenmp-target-debug  Enable debugging in the OpenMP offloading device RTL
+! HELP-FC1-NEXT:                         Generate code only for an OpenMP target device.
+! HELP-FC1-NEXT: -fopenmp-target-debug   Enable debugging in the OpenMP offloading device RTL
 ! HELP-FC1-NEXT: -fopenmp-version=<value>
-! HELP-FC1-NEXT:                        Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
-! HELP-FC1-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
+! HELP-FC1-NEXT:                         Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
+! HELP-FC1-NEXT: -fopenmp                Parse OpenMP pragmas and generate parallel code.
 ! HELP-FC1-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
 ! HELP-FC1-NEXT: -fppc-native-vector-element-order
-! HELP-FC1-NEXT:                        Specifies PowerPC native vector element order
-! HELP-FC1-NEXT: -freciprocal-math      Allow division operations to be reassociated
-! HELP-FC1-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
-! HELP-FC1-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
-! HELP-FC1-NEXT: -funderscoring         Appends one trailing underscore to external names
+! HELP-FC1-NEXT:                         Specifies PowerPC native vector element order (default)
+! HELP-FC1-NEXT: -freciprocal-math       Allow division operations to be reassociated
+! HELP-FC1-NEXT: -fstack-arrays          Attempt to allocate array temporaries on the stack, no matter their size
+! HELP-FC1-NEXT: -fsyntax-only           Run the preprocessor, parser and semantic analysis stages
+! HELP-FC1-NEXT: -funderscoring          Appends one trailing underscore to external names
 ! HELP-FC1-NEXT: -fversion-loops-for-stride
-! HELP-FC1-NEXT:                        Create unit-strided versions of loops
-! HELP-FC1-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
-! HELP-FC1-NEXT: -help                  Display available options
-! HELP-FC1-NEXT: -init-only             Only execute frontend initialization
-! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
-! HELP-FC1-NEXT: -load <dsopath>        Load the named plugin (dynamic shared object)
-! HELP-FC1-NEXT: -menable-no-infs       Allow optimization to assume there are no infinities.
-! HELP-FC1-NEXT: -menable-no-nans       Allow optimization to assume there are no NaNs.
-! HELP-FC1-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
-! HELP-FC1-NEXT: -mmlir <value>         Additional arguments to forward to MLIR's option processing
-! HELP-FC1-NEXT: -module-dir <dir>      Put MODULE files in <dir>
+! HELP-FC1-NEXT:                         Create unit-strided versions of loops
+! HELP-FC1-NEXT: -fxor-operator          Enable .XOR. as a synonym of .NEQV.
+! HELP-FC1-NEXT: -help                   Display available options
+! HELP-FC1-NEXT: -init-only              Only execute frontend initialization
+! HELP-FC1-NEXT: -I <dir>                Add directory to the end of the list of include search paths
+! HELP-FC1-NEXT: -load <dsopath>         Load the named plugin (dynamic shared object)
+! HELP-FC1-NEXT: -menable-no-infs        Allow optimization to assume there are no infinities.
+! HELP-FC1-NEXT: -menable-no-nans        Allow optimization to assume there are no NaNs.
+! HELP-FC1-NEXT: -mllvm <value>          Additional arguments to forward to LLVM's option processing
+! HELP-FC1-NEXT: -mmlir <value>          Additional arguments to forward to MLIR's option processing
+! HELP-FC1-NEXT: -module-dir <dir>       Put MODULE files in <dir>
 ! HELP-FC1-NEXT: -module-suffix <suffix> Use <suffix> as the suffix for module files (the default value is `.mod`)
-! HELP-FC1-NEXT: -mreassociate          Allow reassociation transformations for floating-point instructions
+! HELP-FC1-NEXT: -mreassociate           Allow reassociation transformations for floating-point instructions
 ! HELP-FC1-NEXT: -mrelocation-model <value>
-! HELP-FC1-NEXT:                        The relocation model to use
-! HELP-FC1-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
+! HELP-FC1-NEXT:                         The relocation model to use
+! HELP-FC1-NEXT: -nocpp                  Disable predefined and command line preprocessor macros
 ! HELP-FC1-NEXT: -opt-record-file <value>
-! HELP-FC1-NEXT:                        File name to use for YAML optimization record output
+! HELP-FC1-NEXT:                         File name to use for YAML optimization record output
 ! HELP-FC1-NEXT: -opt-record-format <value>
-! HELP-FC1-NEXT:                        The format used for serializing remarks (default: YAML)
+! HELP-FC1-NEXT:                         The format used for serializing remarks (default: YAML)
 ! HELP-FC1-NEXT: -opt-record-passes <value>
-! HELP-FC1-NEXT:                        Only record remark information for passes whose names match the given regular expression
-! HELP-FC1-NEXT: -o <file>              Write output to <file>
-! HELP-FC1-NEXT: -pedantic              Warn on language extensions
+! HELP-FC1-NEXT:                         Only record remark information for passes whose names match the given regular expression
+! HELP-FC1-NEXT: -o <file>               Write output to <file>
+! HELP-FC1-NEXT: -pedantic               Warn on language extensions
 ! HELP-FC1-NEXT: -pic-is-pie             File is for a position independent executable
 ! HELP-FC1-NEXT: -pic-level <value>      Value for __PIC__
-! HELP-FC1-NEXT: -plugin <name>         Use the named plugin action instead of the default action (use "help" to list available options)
-! HELP-FC1-NEXT: -P                     Disable linemarker output in -E mode
+! HELP-FC1-NEXT: -plugin <name>          Use the named plugin action instead of the default action (use "help" to list available options)
+! HELP-FC1-NEXT: -P                      Disable linemarker output in -E mode
 ! HELP-FC1-NEXT: -Rpass-analysis=<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression
 ! HELP-FC1-NEXT: -Rpass-missed=<value>   Report missed transformations by optimization passes whose name matches the given POSIX regular expression
 ! HELP-FC1-NEXT: -Rpass=<value>          Report transformations performed by optimization passes whose name matches the given POSIX regular expression
 ! HELP-FC1-NEXT: -R<remark>              Enable the specified remark
-! HELP-FC1-NEXT: -save-temps=<value>    Save intermediate compilation results.
-! HELP-FC1-NEXT: -save-temps            Save intermediate compilation results
-! HELP-FC1-NEXT: -std=<value>           Language standard to compile for
-! HELP-FC1-NEXT: -S                     Only run preprocess and compilation steps
-! HELP-FC1-NEXT: -target-cpu <value>    Target a specific cpu type
+! HELP-FC1-NEXT: -save-temps=<value>     Save intermediate compilation results.
+! HELP-FC1-NEXT: -save-temps             Save intermediate compilation results
+! HELP-FC1-NEXT: -std=<value>            Language standard to compile for
+! HELP-FC1-NEXT: -S                      Only run preprocess and compilation steps
+! HELP-FC1-NEXT: -target-cpu <value>     Target a specific cpu type
 ! HELP-FC1-NEXT: -target-feature <value> Target specific attributes
-! HELP-FC1-NEXT: -test-io               Run the InputOuputTest action. Use for development and testing only.
-! HELP-FC1-NEXT: -triple <value>        Specify target triple (e.g. i686-apple-darwin9)
-! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
-! HELP-FC1-NEXT: -version               Print the compiler version
-! HELP-FC1-NEXT: -W<warning>            Enable the specified warning
+! HELP-FC1-NEXT: -test-io                Run the InputOuputTest action. Use for development and testing only.
+! HELP-FC1-NEXT: -triple <value>         Specify target triple (e.g. i686-apple-darwin9)
+! HELP-FC1-NEXT: -U <macro>              Undefine macro <macro>
+! HELP-FC1-NEXT: -version                Print the compiler version
+! HELP-FC1-NEXT: -W<warning>             Enable the specified warning
+! HELP-FC1-NEXT: -x <language>           Treat subsequent input files as having type <language>
 
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Driver/fast_math.f90

 ! RUN:     | FileCheck --check-prefix=CHECK-CONTRACT %s
 ! CHECK-CONTRACT: -fc1
 ! CHECK-CONTRACT-SAME: -ffp-contract=off
 
 ! Check that -ffast-math causes us to link to crtfastmath.o
 ! UNSUPPORTED: system-windows
 ! UNSUPPORTED: target=powerpc{{.*}}
 ! RUN: %flang -ffast-math -### %s -o %t 2>&1 \
-! RUN:           --target=x86_64-unknown-linux -no-pie --gcc-toolchain="" \
+! RUN:           --target=x86_64-unknown-linux -no-pie \
 ! RUN:           --sysroot=%S/../../../clang/test/Driver/Inputs/basic_linux_tree \
 ! RUN:     | FileCheck --check-prefix=CHECK-CRT %s
 ! CHECK-CRT: {{crtbegin.?\.o}}
 ! CHECK-CRT-SAME: crtfastmath.o
 ! CHECK-CRT-SAME: {{crtend.?\.o}}