Move f optimizations to clang_ignored_gcc_optimization_f_Group

[bubbles231]

Summary

Moved 25 flags to clang_ignored_gcc_optimization_f_Group. Will display a warning to the user if they try to pass those optimizations.

Patch by Arthur Marble <[e-mail]> in the context of Debian Google Summer of code 2014.

[sylvestre.ledru]

include/clang/Driver/Options.td

478–479

This one too

1613–1614

For other reviewers, it is an optim flag.

[bubbles231]

Add -fdefer-pop to the group and update the code so it applies with new revisions.

[bubbles231]

Update patch to be compatible with new revision.

[rnk]

include/clang/Driver/Options.td

574

This isn't an optimization flag, IMO. This is the equivalent of changing all discardable (linkonce / linkonce_odr) globals to non-discardable globals (weak / weak_odr). I know it's in GCC optimization flag docs, but it's more of a correctness workaround for invalid code.

689

ditto, not optimization.

Actually, while you're at it, can you make this a BooleanFFlag to reduce duplication?

1585–1587

Hm, these are probably easy to implement in LLVM today. No action needed, though, this change is right.

test/Driver/clang_f_opts.c

173–200

These are lots of subprocess invocations. You can speed up the test significantly by making this all one compiler invocation along the lines of:

// RUN: %clang -### %s \
// RUN:  -fflag \
// ...
// RUN: 2>&1 | FileCheck --check-prefix=CHECK-WARNING %s
// CHECK-WARNING-DAG: optimization flag '-fflag' is not supported
// ...

[bubbles231]

Make requested changes.

[sylvestre.ledru]

rnk, is it ok with you too?

[sylvestre.ledru]

Merged by Arthur on my request as commit r213365 to make sure it gets in 3.5.
rnk, don't hesitate to drop us a mail if you see anything wrong.

include/clang/Driver/Options.td

def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>,
     HelpText<"Do not elide types when printing diagnostics">;
 def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbols">, Group<f_Group>;
 def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Emit all declarations, even if unused">;
 def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>;
 def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>;
 def fexceptions : Flag<["-"], "fexceptions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable support for exception handling">;
-def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_f_Group>;
-def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_f_Group>;
+def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
+def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>;
-def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_f_Group>;
-def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_f_Group>;
+def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
+def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;
 def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>;
 def fhosted : Flag<["-"], "fhosted">, Group<f_Group>;
 def ffast_math : Flag<["-"], "ffast-math">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable the *frontend*'s 'fast-math' mode. This has no effect on "
            "optimizations, but provides a preprocessor macro __FAST_MATH__ the "
            "same as GCC's -ffast-math flag">;
 def fno_fast_math : Flag<["-"], "fno-fast-math">, Group<f_Group>;

 def fgnu89_inline : Flag<["-"], "fgnu89-inline">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use the gnu89 inline semantics">;
 def fno_gnu89_inline : Flag<["-"], "fno-gnu89-inline">, Group<f_Group>;
 def fgnu_runtime : Flag<["-"], "fgnu-runtime">, Group<f_Group>,
   HelpText<"Generate output compatible with the standard GNU Objective-C runtime">;
 def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>;
 def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>;
 def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>;
-def finline_functions : Flag<["-"], "finline-functions">, Group<clang_ignored_f_Group>;
+def finline_functions : Flag<["-"], "finline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Generate calls to instrument function entry and exit">;
-def : Flag<["-"], "fkeep-inline-functions">, Group<clang_ignored_f_Group>;
+def : Flag<["-"], "fkeep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 def flat__namespace : Flag<["-"], "flat_namespace">;
 def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>;
 def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>;
 def flto : Flag<["-"], "flto">, Group<f_Group>;
 def fno_lto : Flag<["-"], "fno-lto">, Group<f_Group>;
 def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">,
                                 Group<f_Group>;
 def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>;
def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>,
   HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>;
 def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>,
   HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>;
 def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>;
 def fno_exceptions : Flag<["-"], "fno-exceptions">, Group<f_Group>;
 def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
-def : Flag<["-"], "fno-keep-inline-functions">, Group<clang_ignored_f_Group>;
+def : Flag<["-"], "fno-keep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
   HelpText<"Disallow implicit conversions between vectors with a different number of elements or different element types">, Flags<[CC1Option]>;
 def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
     Flags<[CC1Option]>, HelpText<"Disallow merging of constants">;
 def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_module_maps : Flag <["-"], "fno-module-maps">, Group<f_Group>,
   Flags<[DriverOption]>;

 def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
 def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>;
 def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Override the default ABI to return small structs in registers">;
 def frtti : Flag<["-"], "frtti">, Group<f_Group>;
 def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;
 def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
-def : Flag<["-"], "freorder-blocks">, Group<clang_ignored_f_Group>;
+def : Flag<["-"], "freorder-blocks">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Force wchar_t to be a short unsigned int">;
 def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Force wchar_t to be an unsigned int">;
 def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Which overload candidates to show when overload resolution fails: "
            "best|all; defaults to all">;
 def fshow_column : Flag<["-"], "fshow-column">, Group<f_Group>, Flags<[CC1Option]>;

 // Ignored options
 // FIXME: multiclasess produce suffixes, not prefixes. This is fine for now
 // since it is only used in ignored options.
 multiclass BooleanFFlag<string name> {
   def _f : Flag<["-"], "f"#name>;
   def _fno : Flag<["-"], "fno-"#name>;
 }
 
-def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<clang_ignored_f_Group>;
+def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<clang_ignored_gcc_optimization_f_Group>;
 
-defm profile_use : BooleanFFlag<"profile-use">, Group<clang_ignored_f_Group>;
-def fprofile_use_EQ : Joined<["-"], "fprofile-use=">, Group<clang_ignored_f_Group>;
+defm profile_use : BooleanFFlag<"profile-use">, Group<clang_ignored_gcc_optimization_f_Group>;
+def fprofile_use_EQ : Joined<["-"], "fprofile-use=">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>;
 
-defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_f_Group>;
-def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_f_Group>;
+defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
+def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 // FIXME: This option should be supported and wired up to our diognostics, but
 // ignore it for now to avoid breaking builds that use it.
 def fdiagnostics_show_location_EQ : Joined<["-"], "fdiagnostics-show-location=">, Group<clang_ignored_f_Group>;
 
 defm eliminate_unused_debug_types : BooleanFFlag<"eliminate-unused-debug-types">, Group<clang_ignored_f_Group>;
-defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_f_Group>;
+defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm function_attribute_list : BooleanFFlag<"function-attribute-list">, Group<clang_ignored_f_Group>;
-defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_f_Group>;
+defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gnu : BooleanFFlag<"gnu">, Group<clang_ignored_f_Group>;
 defm ident : BooleanFFlag<"ident">, Group<clang_ignored_f_Group>;
 defm implicit_templates : BooleanFFlag<"implicit-templates">, Group<clang_ignored_f_Group>;
 def finline_limit_EQ : Joined<["-"], "finline-limit=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm finline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_gcc_optimization_f_Group>;
-defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_f_Group>;
+defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>;
 defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>;
-defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_f_Group>;
+defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm printf : BooleanFFlag<"printf">, Group<clang_ignored_f_Group>;
 defm profile : BooleanFFlag<"profile">, Group<clang_ignored_f_Group>;
-defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_f_Group>;
+defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm profile_generate_sampling : BooleanFFlag<"profile-generate-sampling">, Group<clang_ignored_f_Group>;
 defm profile_reusedist : BooleanFFlag<"profile-reusedist">, Group<clang_ignored_f_Group>;
-defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_f_Group>;
+defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>;
 defm ripa : BooleanFFlag<"ripa">, Group<clang_ignored_f_Group>;
-defm rounding_math : BooleanFFlag<"rounding-math">, Group<clang_ignored_f_Group>;
-defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_f_Group>;
+defm rounding_math : BooleanFFlag<"rounding-math">, Group<clang_ignored_gcc_optimization_f_Group>;
+defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm see : BooleanFFlag<"see">, Group<clang_ignored_f_Group>;
-defm signaling_nans : BooleanFFlag<"signaling-nans">, Group<clang_ignored_f_Group>;
+defm signaling_nans : BooleanFFlag<"signaling-nans">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm spec_constr_count : BooleanFFlag<"spec-constr-count">, Group<clang_ignored_f_Group>;
 defm strength_reduce :
-    BooleanFFlag<"strength-reduce">, Group<clang_ignored_f_Group>;
+    BooleanFFlag<"strength-reduce">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm tls_model : BooleanFFlag<"tls-model">, Group<clang_ignored_f_Group>;
-defm tracer : BooleanFFlag<"tracer">, Group<clang_ignored_f_Group>;
+defm tracer : BooleanFFlag<"tracer">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm tree_salias : BooleanFFlag<"tree-salias">, Group<clang_ignored_f_Group>;
 defm tree_vectorizer_verbose : BooleanFFlag<"tree-vectorizer-verbose">, Group<clang_ignored_f_Group>;
-defm unroll_all_loops : BooleanFFlag<"unroll-all-loops">, Group<clang_ignored_f_Group>;
-defm unswitch_loops : BooleanFFlag<"unswitch-loops">, Group<clang_ignored_f_Group>;
+defm unroll_all_loops : BooleanFFlag<"unroll-all-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
+defm unswitch_loops : BooleanFFlag<"unswitch-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 
 // gfortran options that we recognize in the driver and pass along when
 // invoking GCC to compile Fortran code.
 def gfortran_Group : OptionGroup<"gfortran Group">;
 
 // Generic gfortran options.
 def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>;

test/Driver/clang_f_opts.c

 // RUN:     -fno-signed-char                                                  \
 // RUN:     -fstrength-reduce -fno-strength-reduce                            \
 // RUN:     -finline-limit=1000                                               \
 // RUN:     -finline-limit                                                    \
 // RUN:     %s 2>&1 | FileCheck --check-prefix=IGNORE %s
 // IGNORE-NOT: error: unknown argument
 
 // Test that the warning is displayed on these.
 // RUN: %clang -### -finline-limit=1000 %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING1 %s
 // RUN: %clang -### -finline-limit %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING2 %s
+// RUN: %clang -### -fexpensive-optimizations %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING3 %s
+// RUN: %clang -### -fno-expensive-optimizations %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING4 %s
+// RUN: %clang -### -fno-defer-pop %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING5 %s
+// RUN: %clang -### -finline-functions %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING6 %s
+// RUN: %clang -### -fkeep-inline-functions %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING7 %s
+// RUN: %clang -### -fno-keep-inline-functions %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING8 %s
+// RUN: %clang -### -freorder-blocks %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING9 %s
+// RUN: %clang -### -fprofile-dir=/rand/dir %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING10 %s
+// RUN: %clang -### -fprofile-use %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING11 %s
+// RUN: %clang -### -fprofile-use=/rand/dir %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING12 %s
+// RUN: %clang -### -falign-functions %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING13 %s
+// RUN: %clang -### -falign-functions=1 %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING14 %s
+// RUN: %clang -### -ffloat-store %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING15 %s
+// RUN: %clang -### -fgcse %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING16 %s
+// RUN: %clang -### -fivopts %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING17 %s
+// RUN: %clang -### -fprefetch-loop-arrays %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING18 %s
+// RUN: %clang -### -fprofile-correction %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING19 %s
+// RUN: %clang -### -fprofile-values %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING20 %s
+// RUN: %clang -### -frounding-math %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING21 %s
+// RUN: %clang -### -fschedule-insns %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING22 %s
+// RUN: %clang -### -fsignaling-nans %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING23 %s
+// RUN: %clang -### -fstrength-reduce %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING24 %s
+// RUN: %clang -### -ftracer %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING25 %s
+// RUN: %clang -### -funroll-all-loops %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING26 %s
+// RUN: %clang -### -funswitch-loops %s 2>&1 | FileCheck --check-prefix=CHECK-WARNING27 %s
 // CHECK-WARNING1: ignoring unsupported optimization flag '-finline-limit=1000'
 // CHECK-WARNING2: ignoring unsupported optimization flag '-finline-limit'
+// CHECK-WARNING3: ignoring unsupported optimization flag '-fexpensive-optimizations'
+// CHECK-WARNING4: ignoring unsupported optimization flag '-fno-expensive-optimizations'
+// CHECK-WARNING5: ignoring unsupported optimization flag '-fno-defer-pop'
+// CHECK-WARNING6: ignoring unsupported optimization flag '-finline-functions'
+// CHECK-WARNING7: ignoring unsupported optimization flag '-fkeep-inline-functions'
+// CHECK-WARNING8: ignoring unsupported optimization flag '-fno-keep-inline-functions'
+// CHECK-WARNING9: ignoring unsupported optimization flag '-freorder-blocks'
+// CHECK-WARNING10: ignoring unsupported optimization flag '-fprofile-dir=/rand/dir'
+// CHECK-WARNING11: ignoring unsupported optimization flag '-fprofile-use'
+// CHECK-WARNING12: ignoring unsupported optimization flag '-fprofile-use=/rand/dir'
+// CHECK-WARNING13: ignoring unsupported optimization flag '-falign-functions'
+// CHECK-WARNING14: ignoring unsupported optimization flag '-falign-functions=1'
+// CHECK-WARNING15: ignoring unsupported optimization flag '-ffloat-store'
+// CHECK-WARNING16: ignoring unsupported optimization flag '-fgcse'
+// CHECK-WARNING17: ignoring unsupported optimization flag '-fivopts'
+// CHECK-WARNING18: ignoring unsupported optimization flag '-fprefetch-loop-arrays'
+// CHECK-WARNING19: ignoring unsupported optimization flag '-fprofile-correction'
+// CHECK-WARNING20: ignoring unsupported optimization flag '-fprofile-values'
+// CHECK-WARNING21: ignoring unsupported optimization flag '-frounding-math'
+// CHECK-WARNING22: ignoring unsupported optimization flag '-fschedule-insns'
+// CHECK-WARNING23: ignoring unsupported optimization flag '-fsignaling-nans'
+// CHECK-WARNING24: ignoring unsupported optimization flag '-fstrength-reduce'
+// CHECK-WARNING25: ignoring unsupported optimization flag '-ftracer'
+// CHECK-WARNING26: ignoring unsupported optimization flag '-funroll-all-loops'
+// CHECK-WARNING27: ignoring unsupported optimization flag '-funswitch-loops'
 
 // Test that we mute the warning on these
 // RUN: %clang -### -finline-limit=1000 -Wno-unused-command-line-argument               \
 // RUN:     %s 2>&1 | FileCheck --check-prefix=CHECK-NO-WARNING1 %s
 // RUN: %clang -### -finline-limit -Wno-unused-command-line-argument                    \
 // RUN:     %s 2>&1 | FileCheck --check-prefix=CHECK-NO-WARNING2 %s
 // CHECK-NO-WARNING1-NOT: ignoring unsupported optimization flag '-finline-limit=1000'
 // CHECK-NO-WARNING2-NOT: ignoring unsupported optimization flag '-finline-limit'
 
 
 // RUN: %clang -### -fshort-wchar -fno-short-wchar %s 2>&1 | FileCheck -check-prefix=CHECK-WCHAR1 %s
 // RUN: %clang -### -fno-short-wchar -fshort-wchar %s 2>&1 | FileCheck -check-prefix=CHECK-WCHAR2 %s
 // CHECK-WCHAR1: -fno-short-wchar
 // CHECK-WCHAR1-NOT: -fshort-wchar
 // CHECK-WCHAR2: -fshort-wchar
 // CHECK-WCHAR2-NOT: -fno-short-wchar