diff options
| -rw-r--r-- | clang/include/clang/Basic/CodeGenOptions.h | 2 | ||||
| -rw-r--r-- | clang/include/clang/Basic/DiagnosticDriverKinds.td | 2 | ||||
| -rw-r--r-- | clang/include/clang/Basic/DiagnosticFrontendKinds.td | 2 | ||||
| -rw-r--r-- | clang/include/clang/Driver/Options.td | 1364 | ||||
| -rw-r--r-- | clang/lib/Frontend/CompilerInvocation.cpp | 901 | ||||
| -rw-r--r-- | clang/test/Profile/c-generate.c | 2 | ||||
| -rw-r--r-- | clang/unittests/Frontend/CompilerInvocationTest.cpp | 84 | ||||
| -rw-r--r-- | llvm/include/llvm/Option/OptParser.td | 18 |
8 files changed, 1033 insertions, 1342 deletions
diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h index 5c54081..ef4fa31 100644 --- a/clang/include/clang/Basic/CodeGenOptions.h +++ b/clang/include/clang/Basic/CodeGenOptions.h @@ -30,6 +30,8 @@ namespace clang { /// Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure /// that this large collection of bitfields is a trivial class type. class CodeGenOptionsBase { + friend class CompilerInvocation; + public: #define CODEGENOPT(Name, Bits, Default) unsigned Name : Bits; #define ENUM_CODEGENOPT(Name, Type, Bits, Default) diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td index 892fb1c..e92a4bf 100644 --- a/clang/include/clang/Basic/DiagnosticDriverKinds.td +++ b/clang/include/clang/Basic/DiagnosticDriverKinds.td @@ -86,8 +86,6 @@ def err_drv_invalid_thread_model_for_target : Error< "invalid thread model '%0' in '%1' for this target">; def err_drv_invalid_linker_name : Error< "invalid linker name in argument '%0'">; -def err_drv_invalid_pgo_instrumentor : Error< - "invalid PGO instrumentor in argument '%0'">; def err_drv_invalid_rtlib_name : Error< "invalid runtime library name in argument '%0'">; def err_drv_unsupported_rtlib_for_platform : Error< diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td b/clang/include/clang/Basic/DiagnosticFrontendKinds.td index def189f..b9f8c78 100644 --- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td @@ -108,8 +108,6 @@ def err_fe_action_not_available : Error< "action %0 not compiled in">; def err_fe_invalid_alignment : Error< "invalid value '%1' in '%0'; alignment must be a power of 2">; -def err_fe_invalid_wchar_type - : Error<"invalid wchar_t type '%0'; must be one of 'char', 'short', 'int'">; def err_fe_invalid_exception_model : Error<"invalid exception model '%select{none|dwarf|sjlj|arm|seh|wasm|aix}0' for target '%1'">; def warn_fe_concepts_ts_flag : Warning< diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index c7da888..3c2a9f3 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -696,7 +696,7 @@ def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["1"]>; def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>; def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group<Preprocessor_Group>, HelpText<"Disable linemarker output in -E mode">, - MarshallingInfoFlag<"PreprocessorOutputOpts.ShowLineMarkers", "true">, IsNegative; + MarshallingInfoNegativeFlag<"PreprocessorOutputOpts.ShowLineMarkers">; def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>, HelpText<"Emit metadata containing compiler name and version">; def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>, @@ -910,8 +910,10 @@ def fcuda_flush_denormals_to_zero : Flag<["-"], "fcuda-flush-denormals-to-zero"> def fno_cuda_flush_denormals_to_zero : Flag<["-"], "fno-cuda-flush-denormals-to-zero">; defm cuda_approx_transcendentals : OptInFFlag<"cuda-approx-transcendentals", "Use", "Don't use", " approximate transcendental functions">; -defm gpu_rdc : OptInFFlag<"gpu-rdc", - "Generate relocatable device code, also known as separate compilation mode", "", "">; +defm gpu_rdc : BoolFOption<"gpu-rdc", + "LangOpts->GPURelocatableDeviceCode", DefaultsToFalse, + ChangedBy<PosFlag, [], "Generate relocatable device code, also known as separate compilation mode">, + ResetBy<NegFlag>>; def : Flag<["-"], "fcuda-rdc">, Alias<fgpu_rdc>; def : Flag<["-"], "fno-cuda-rdc">, Alias<fno_gpu_rdc>; defm cuda_short_ptr : OptInFFlag<"cuda-short-ptr", @@ -928,16 +930,21 @@ def hip_version_EQ : Joined<["--"], "hip-version=">, HelpText<"HIP version in the format of major.minor.patch">; def fhip_dump_offload_linker_script : Flag<["-"], "fhip-dump-offload-linker-script">, Group<f_Group>, Flags<[NoArgumentUnused, HelpHidden]>; -defm hip_new_launch_api : OptInFFlag<"hip-new-launch-api", - "Use", "Don't use", " new kernel launching API for HIP">; +defm hip_new_launch_api : BoolFOption<"hip-new-launch-api", + "LangOpts->HIPUseNewLaunchAPI", DefaultsToFalse, + ChangedBy<PosFlag, [], "Use">, ResetBy<NegFlag, [], "Don't use">, + BothFlags<[], " new kernel launching API for HIP">>; defm gpu_allow_device_init : OptInFFlag<"gpu-allow-device-init", "Allow", "Don't allow", " device side init function in HIP">; -defm gpu_defer_diag : OptInFFlag<"gpu-defer-diag", - "Defer", "Don't defer", " host/device related diagnostic messages" - " for CUDA/HIP">; -defm gpu_exclude_wrong_side_overloads : OptInFFlag<"gpu-exclude-wrong-side-overloads", - "Always exclude wrong side overloads", "Exclude wrong side overloads only if there are same side overloads", - " in overloading resolution for CUDA/HIP", [HelpHidden]>; +defm gpu_defer_diag : BoolFOption<"gpu-defer-diag", + "LangOpts->GPUDeferDiag", DefaultsToFalse, + ChangedBy<PosFlag, [], "Defer">, ResetBy<NegFlag, [], "Don't defer">, + BothFlags<[], " host/device related diagnostic messages for CUDA/HIP">>; +defm gpu_exclude_wrong_side_overloads : BoolFOption<"gpu-exclude-wrong-side-overloads", + "LangOpts->GPUExcludeWrongSideOverloads", DefaultsToFalse, + ChangedBy<PosFlag, [], "Always exclude wrong side overloads">, + ResetBy<NegFlag, [], "Exclude wrong side overloads only if there are same side overloads">, + BothFlags<[HelpHidden], " in overloading resolution for CUDA/HIP">>; def gpu_max_threads_per_block_EQ : Joined<["--"], "gpu-max-threads-per-block=">, Flags<[CC1Option]>, HelpText<"Default max threads per block for kernel launch bounds for HIP">; @@ -989,21 +996,31 @@ def interface_stub_version_EQ : JoinedOrSeparate<["-"], "interface-stub-version= def exported__symbols__list : Separate<["-"], "exported_symbols_list">; def e : JoinedOrSeparate<["-"], "e">, Flags<[LinkerInput]>, Group<Link_Group>; def fmax_tokens_EQ : Joined<["-"], "fmax-tokens=">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Max total number of preprocessed tokens for -Wmax-tokens.">; + HelpText<"Max total number of preprocessed tokens for -Wmax-tokens.">, + MarshallingInfoStringInt<"LangOpts->MaxTokens">; 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>; -defm access_control : OptOutFFlag<"access-control", "", "Disable C++ access control">; +defm access_control : BoolFOption<"access-control", + "LangOpts->AccessControl", DefaultsToTrue, + ChangedBy<NegFlag, [], "Disable C++ access control">, + ResetBy<PosFlag>>; def falign_functions : Flag<["-"], "falign-functions">, Group<f_Group>; def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<f_Group>; def fno_align_functions: Flag<["-"], "fno-align-functions">, Group<f_Group>; -defm allow_editor_placeholders : OptInFFlag<"allow-editor-placeholders", "Treat editor placeholders as valid source code">; +defm allow_editor_placeholders : BoolFOption<"allow-editor-placeholders", + "LangOpts->AllowEditorPlaceholders", DefaultsToFalse, + ChangedBy<PosFlag, [], "Treat editor placeholders as valid source code">, + ResetBy<NegFlag>>; def fallow_unsupported : Flag<["-"], "fallow-unsupported">, Group<f_Group>; def fapple_kext : Flag<["-"], "fapple-kext">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Use Apple's kernel extensions ABI">; -def fapple_pragma_pack : Flag<["-"], "fapple-pragma-pack">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Enable Apple gcc-compatible #pragma pack handling">; + HelpText<"Use Apple's kernel extensions ABI">, + MarshallingInfoFlag<"LangOpts->AppleKext">; +defm apple_pragma_pack : BoolFOption<"apple-pragma-pack", + "LangOpts->ApplePragmaPack", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable Apple gcc-compatible #pragma pack handling">, + ResetBy<NegFlag>>; def shared_libsan : Flag<["-"], "shared-libsan">, HelpText<"Dynamically link the sanitizer runtime">; def static_libsan : Flag<["-"], "static-libsan">, @@ -1036,14 +1053,19 @@ defm coroutines_ts : OptInFFlag<"coroutines-ts", "Enable support for the C++ Cor def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">, Group<f_Group>, Flags<[NoXarchOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">, - HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">; + HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">, + Values<"off,all,bitcode,marker">, NormalizedValuesScope<"CodeGenOptions">, + NormalizedValues<["Embed_Off", "Embed_All", "Embed_Bitcode", "Embed_Marker"]>, + MarshallingInfoString<"CodeGenOpts.EmbedBitcode", "Embed_Off">, AutoNormalizeEnum; def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>, Alias<fembed_bitcode_EQ>, AliasArgs<["all"]>, HelpText<"Embed LLVM IR bitcode as data">; def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">, Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>, HelpText<"Embed placeholder LLVM IR data as a marker">; -defm gnu_inline_asm : OptOutFFlag<"gnu-inline-asm", "", "Disable GNU style inline asm">; +defm gnu_inline_asm : BoolFOption<"gnu-inline-asm", + "LangOpts->GNUAsm", DefaultsToTrue, + ChangedBy<NegFlag, [], "Disable GNU style inline asm">, ResetBy<PosFlag>>; def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>, Flags<[CoreOption]>; @@ -1051,14 +1073,16 @@ def fno_profile_sample_use : Flag<["-"], "fno-profile-sample-use">, Group<f_Grou Flags<[CoreOption]>; def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">, Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, - HelpText<"Enable sample-based profile guided optimizations">; + HelpText<"Enable sample-based profile guided optimizations">, + MarshallingInfoString<"CodeGenOpts.SampleProfileFile">; def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">, Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, HelpText<"Specifies that the sample profile is accurate">, DocBrief<[{Specifies that the sample profile is accurate. If the sample profile is accurate, callsites without profile samples are marked as cold. Otherwise, treat callsites without profile samples as if - we have no profile}]>; + we have no profile}]>, + MarshallingInfoFlag<"CodeGenOpts.ProfileSampleAccurate">; def fno_profile_sample_accurate : Flag<["-"], "fno-profile-sample-accurate">, Group<f_Group>, Flags<[NoXarchOption]>; def fauto_profile : Flag<["-"], "fauto-profile">, Group<f_Group>, @@ -1073,12 +1097,15 @@ def fno_auto_profile_accurate : Flag<["-"], "fno-auto-profile-accurate">, Group<f_Group>, Alias<fno_profile_sample_accurate>; def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">, Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>, - HelpText<"The compilation directory to embed in the debug info.">; + HelpText<"The compilation directory to embed in the debug info.">, + MarshallingInfoString<"CodeGenOpts.DebugCompilationDir">; def fdebug_compilation_dir_EQ : Joined<["-"], "fdebug-compilation-dir=">, Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>, Alias<fdebug_compilation_dir>; -defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling", - "Emit extra debug info to make sample profile more accurate">; +defm debug_info_for_profiling : BoolFOption<"debug-info-for-profiling", + "CodeGenOpts.DebugInfoForProfiling", DefaultsToFalse, + ChangedBy<PosFlag, [], "Emit extra debug info to make sample profile more accurate">, + ResetBy<NegFlag>>; def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">, Group<f_Group>, Flags<[CoreOption]>, HelpText<"Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">; @@ -1092,12 +1119,14 @@ def fprofile_instr_use_EQ : Joined<["-"], "fprofile-instr-use=">, HelpText<"Use instrumentation data for profile-guided optimization">; def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">, - HelpText<"Use the remappings described in <file> to match the profile data against names in the program">; + HelpText<"Use the remappings described in <file> to match the profile data against names in the program">, + MarshallingInfoString<"CodeGenOpts.ProfileRemappingFile">; def fprofile_remapping_file : Separate<["-"], "fprofile-remapping-file">, Group<f_Group>, Flags<[CoreOption]>, Alias<fprofile_remapping_file_EQ>; -defm coverage_mapping : OptInFFlag<"coverage-mapping", - "Generate coverage mapping to enable code coverage analysis", "Disable code coverage analysis", "", - [CoreOption]>; +defm coverage_mapping : BoolFOption<"coverage-mapping", + "CodeGenOpts.CoverageMapping", DefaultsToFalse, + ChangedBy<PosFlag, [], "Generate coverage mapping to enable code coverage analysis">, + ResetBy<NegFlag, [], "Disable code coverage analysis">, BothFlags<[CoreOption]>>; def fprofile_generate : Flag<["-"], "fprofile-generate">, Group<f_Group>, Flags<[CoreOption]>, HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">; @@ -1134,22 +1163,26 @@ def fprofile_exclude_files_EQ : Joined<["-"], "fprofile-exclude-files=">, HelpText<"Instrument only functions from files where names don't match all the regexes separated by a semi-colon">; def fprofile_update_EQ : Joined<["-"], "fprofile-update=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, Values<"atomic,prefer-atomic,single">, - MetaVarName<"<method>">, HelpText<"Set update method of profile counters (atomic,prefer-atomic,single)">; -def fpseudo_probe_for_profiling : Flag<["-"], "fpseudo-probe-for-profiling">, - Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, - HelpText<"Emit pseudo probes for sample profiler">; -def fno_pseudo_probe_for_profiling : Flag<["-"], "fno-pseudo-probe-for-profiling">, - Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, - HelpText<"Do not emit pseudo probes for sample profiler.">; + MetaVarName<"<method>">, HelpText<"Set update method of profile counters (atomic,prefer-atomic,single)">, + MarshallingInfoFlag<"CodeGenOpts.AtomicProfileUpdate">; +defm pseudo_probe_for_profiling : BoolFOption<"pseudo-probe-for-profiling", + "CodeGenOpts.PseudoProbeForProfiling", DefaultsToFalse, + ChangedBy<PosFlag, [], "Emit">, ResetBy<NegFlag, [], "Do not emit">, + BothFlags<[NoXarchOption, CC1Option], " pseudo probes for sample profiler">>; def forder_file_instrumentation : Flag<["-"], "forder-file-instrumentation">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, HelpText<"Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">; -defm addrsig : OptInFFlag<"addrsig", "Emit", "Don't emit", " an address-significance table", [CoreOption]>; +defm addrsig : BoolFOption<"addrsig", + "CodeGenOpts.Addrsig", DefaultsToFalse, + ChangedBy<PosFlag, [], "Emit">, ResetBy<NegFlag, [], "Don't emit">, + BothFlags<[CoreOption], " an address-significance table">>; defm blocks : OptInFFlag<"blocks", "Enable the 'blocks' language feature", "", "", [CoreOption]>; def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>; -def fborland_extensions : Flag<["-"], "fborland-extensions">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Accept non-standard constructs supported by the Borland compiler">; +defm borland_extensions : BoolFOption<"borland-extensions", + "LangOpts->Borland", DefaultsToFalse, + ChangedBy<PosFlag, [], "Accept non-standard constructs supported by the Borland compiler">, + ResetBy<NegFlag>>; def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>, Flags<[CoreOption]>; def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>, Flags<[NoXarchOption]>, HelpText<"Load the clang builtins module map file.">; @@ -1178,29 +1211,39 @@ def fno_record_command_line : Flag<["-"], "fno-record-command-line">, def : Flag<["-"], "frecord-gcc-switches">, Alias<frecord_command_line>; def : Flag<["-"], "fno-record-gcc-switches">, Alias<fno_record_command_line>; def fcommon : Flag<["-"], "fcommon">, Group<f_Group>, - Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">; + Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">, + MarshallingInfoNegativeFlag<"CodeGenOpts.NoCommon">; def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>; -def fcomplete_member_pointers : Flag<["-"], "fcomplete-member-pointers">, Group<f_clang_Group>, - Flags<[CoreOption, CC1Option]>, - HelpText<"Require member pointer base types to be complete if they would be significant under the Microsoft ABI">; -def fno_complete_member_pointers : Flag<["-"], "fno-complete-member-pointers">, Group<f_clang_Group>, - Flags<[CoreOption]>, - HelpText<"Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI">; +defm complete_member_pointers : BoolOption<"complete-member-pointers", + "LangOpts->CompleteMemberPointers", DefaultsToFalse, + ChangedBy<PosFlag, [CC1Option], "Require">, ResetBy<NegFlag, [], "Do not require">, + BothFlags<[CoreOption], " member pointer base types to be complete if they" + " would be significant under the Microsoft ABI">, "f">, + Group<f_clang_Group>; def fcf_runtime_abi_EQ : Joined<["-"], "fcf-runtime-abi=">, Group<f_Group>, - Flags<[CC1Option]>; -def fconstant_cfstrings : Flag<["-"], "fconstant-cfstrings">, Group<f_Group>; + Flags<[CC1Option]>, Values<"unspecified,standalone,objc,swift,swift-5.0,swift-4.2,swift-4.1">, + NormalizedValuesScope<"LangOptions::CoreFoundationABI">, + NormalizedValues<["ObjectiveC", "ObjectiveC", "ObjectiveC", "Swift5_0", "Swift5_0", "Swift4_2", "Swift4_1"]>, + MarshallingInfoString<"LangOpts->CFRuntime", "ObjectiveC">, AutoNormalizeEnum; +defm constant_cfstrings : BoolFOption<"constant-cfstrings", + "LangOpts->NoConstantCFStrings", DefaultsToFalse, + ChangedBy<NegFlag, [], "Disable creation of CodeFoundation-type constant strings">, + ResetBy<PosFlag>>; def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>; def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>; def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>; def fexperimental_new_constant_interpreter : Flag<["-"], "fexperimental-new-constant-interpreter">, Group<f_Group>, - HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>; + HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>, + MarshallingInfoFlag<"LangOpts->EnableNewConstInterp">; def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">, Group<f_Group>; def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>, HelpText<"Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash">; def fcrash_diagnostics_dir : Joined<["-"], "fcrash-diagnostics-dir=">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>; def fcreate_profile : Flag<["-"], "fcreate-profile">, Group<f_Group>; -defm cxx_exceptions: OptInFFlag<"cxx-exceptions", "Enable C++ exceptions">; +defm cxx_exceptions: BoolFOption<"cxx-exceptions", + "LangOpts->CXXExceptions", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable C++ exceptions">, ResetBy<NegFlag>>; def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>, Flags<[NoXarchOption]>; def fdebug_pass_arguments : Flag<["-"], "fdebug-pass-arguments">, Group<f_Group>; @@ -1213,8 +1256,10 @@ def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits"> def fdiagnostics_print_source_range_info : Flag<["-"], "fdiagnostics-print-source-range-info">, Group<f_clang_Group>, Flags<[CC1Option]>, HelpText<"Print source range spans in numeric form">; -def fdiagnostics_show_hotness : Flag<["-"], "fdiagnostics-show-hotness">, Group<f_Group>, - Flags<[CC1Option]>, HelpText<"Enable profile hotness information in diagnostic line">; +defm diagnostics_show_hotness : BoolFOption<"diagnostics-show-hotness", + "CodeGenOpts.DiagnosticsWithHotness", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable profile hotness information in diagnostic line">, + ResetBy<NegFlag>>; def fdiagnostics_hotness_threshold_EQ : Joined<["-"], "fdiagnostics-hotness-threshold=">, Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<value>">, HelpText<"Prevent optimization remarks from being output if they do not have at least this profile count. " @@ -1238,8 +1283,13 @@ def fdollars_in_identifiers : Flag<["-"], "fdollars-in-identifiers">, Group<f_Gr HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>; def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>; def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>; -defm dwarf_directory_asm : OptOutFFlag<"dwarf-directory-asm", "", "">; -def felide_constructors : Flag<["-"], "felide-constructors">, Group<f_Group>; +defm dwarf_directory_asm : BoolFOption<"dwarf-directory-asm", + "CodeGenOpts.NoDwarfDirectoryAsm", DefaultsToFalse, + ChangedBy<NegFlag>, ResetBy<PosFlag>>; +defm elide_constructors : BoolFOption<"elide-constructors", + "LangOpts->ElideConstructors", DefaultsToTrue, + ChangedBy<NegFlag, [], "Disable C++ copy constructor elision">, + ResetBy<PosFlag>>; def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Do not elide types when printing diagnostics">; @@ -1247,13 +1297,17 @@ def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbo defm eliminate_unused_debug_types : OptOutFFlag<"eliminate-unused-debug-types", "Do not emit ", "Emit ", " debug info for defined but unused types">; def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Emit all declarations, even if unused">; + HelpText<"Emit all declarations, even if unused">, + MarshallingInfoFlag<"LangOpts->EmitAllDecls">; def femulated_tls : Flag<["-"], "femulated-tls">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Use emutls functions to access thread_local variables">; def fno_emulated_tls : Flag<["-"], "fno-emulated-tls">, Group<f_Group>, Flags<[CC1Option]>; def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>; def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>; -defm exceptions : OptInFFlag<"exceptions", "Enable", "Disable", " support for exception handling">; +defm exceptions : BoolFOption<"exceptions", + "LangOpts->Exceptions", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [], "Disable">, + BothFlags<[], " support for exception handling">>; def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group<f_Group>, HelpText<"Use DWARF style exceptions">; def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>, @@ -1272,7 +1326,8 @@ def exception_model : Separate<["-"], "exception-model">, def exception_model_EQ : Joined<["-"], "exception-model=">, Flags<[CC1Option, NoDriverOption]>, Alias<exception_model>; def fignore_exceptions : Flag<["-"], "fignore-exceptions">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Enable support for ignoring exception handling constructs">; + HelpText<"Enable support for ignoring exception handling constructs">, + MarshallingInfoFlag<"LangOpts->IgnoreExceptions">; def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">, Group<clang_ignored_gcc_optimization_f_Group>; def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>; @@ -1298,14 +1353,22 @@ defm math_errno : OptInFFlag<"math-errno", "Require math functions to indicate e def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>, Flags<[CoreOption]>; def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>; def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>; -defm jump_tables : OptOutFFlag<"jump-tables", "Use", "Do not use", " jump tables for lowering switches">; +defm jump_tables : BoolFOption<"jump-tables", + "CodeGenOpts.NoUseJumpTables", DefaultsToFalse, + ChangedBy<NegFlag, [], "Do not use">, ResetBy<PosFlag, [], "Use">, + BothFlags<[], " jump tables for lowering switches">>; defm force_enable_int128 : OptInFFlag<"force-enable-int128", "Enable", "Disable", " support for int128_t type", [], "TargetOpts->ForceEnableInt128">; -defm keep_static_consts : OptInFFlag<"keep-static-consts", "Keep", "Don't keep", " static const variables if unused", [NoXarchOption]>; +defm keep_static_consts : BoolFOption<"keep-static-consts", + "CodeGenOpts.KeepStaticConsts", DefaultsToFalse, + ChangedBy<PosFlag, [], "Keep">, ResetBy<NegFlag, [], "Don't keep">, + BothFlags<[NoXarchOption], " static const variables if unused">>; defm fixed_point : OptInFFlag<"fixed-point", "Enable", "Disable", " fixed point types">; -defm cxx_static_destructors : OptOutFFlag<"c++-static-destructors", "", - "Disable C++ static destructor registration">; +defm cxx_static_destructors : BoolFOption<"c++-static-destructors", + "LangOpts->RegisterStaticDestructors", DefaultsToTrue, + ChangedBy<NegFlag, [], "Disable C++ static destructor registration">, + ResetBy<PosFlag>>; def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>, - Flags<[CC1Option]>; + Flags<[CC1Option]>, MarshallingInfoString<"CodeGenOpts.SymbolPartition">; defm memory_profile : OptInFFlag<"memory-profile", "Enable", "Disable", " heap memory profiling">; def fmemory_profile_EQ : Joined<["-"], "fmemory-profile=">, @@ -1354,7 +1417,8 @@ def : Joined<["-"], "fsanitize-coverage-blacklist=">, HelpText<"Deprecated, use -fsanitize-coverage-blocklist= instead">; def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">, Group<f_clang_Group>, - HelpText<"Enable origins tracking in MemorySanitizer">; + HelpText<"Enable origins tracking in MemorySanitizer">, + MarshallingInfoStringInt<"CodeGenOpts.SanitizeMemoryTrackOrigins">; def fsanitize_memory_track_origins : Flag<["-"], "fsanitize-memory-track-origins">, Group<f_clang_Group>, HelpText<"Enable origins tracking in MemorySanitizer">; @@ -1362,41 +1426,34 @@ def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-o Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>, HelpText<"Disable origins tracking in MemorySanitizer">; -def fsanitize_memory_use_after_dtor : Flag<["-"], "fsanitize-memory-use-after-dtor">, - Group<f_clang_Group>, - HelpText<"Enable use-after-destroy detection in MemorySanitizer">; -def fno_sanitize_memory_use_after_dtor : Flag<["-"], "fno-sanitize-memory-use-after-dtor">, - Group<f_clang_Group>, - HelpText<"Disable use-after-destroy detection in MemorySanitizer">; +defm sanitize_memory_use_after_dtor : BoolOption<"sanitize-memory-use-after-dtor", + "CodeGenOpts.SanitizeMemoryUseAfterDtor", DefaultsToFalse, + ChangedBy<PosFlag, [CC1Option], "Enable">, ResetBy<NegFlag, [], "Disable">, + BothFlags<[], " use-after-destroy detection in MemorySanitizer">, "f">, + Group<f_clang_Group>; def fsanitize_address_field_padding : Joined<["-"], "fsanitize-address-field-padding=">, Group<f_clang_Group>, - HelpText<"Level of field padding for AddressSanitizer">; -def fsanitize_address_use_after_scope : Flag<["-"], "fsanitize-address-use-after-scope">, - Group<f_clang_Group>, - HelpText<"Enable use-after-scope detection in AddressSanitizer">; -def fno_sanitize_address_use_after_scope : Flag<["-"], "fno-sanitize-address-use-after-scope">, - Group<f_clang_Group>, - Flags<[CoreOption, NoXarchOption]>, - HelpText<"Disable use-after-scope detection in AddressSanitizer">; -def fsanitize_address_poison_custom_array_cookie - : Flag<[ "-" ], "fsanitize-address-poison-custom-array-cookie">, - Group<f_clang_Group>, - HelpText<"Enable poisoning array cookies when using custom operator new[] in AddressSanitizer">; -def fno_sanitize_address_poison_custom_array_cookie - : Flag<[ "-" ], "fno-sanitize-address-poison-custom-array-cookie">, - Group<f_clang_Group>, - HelpText<"Disable poisoning array cookies when using custom operator new[] in AddressSanitizer">; + HelpText<"Level of field padding for AddressSanitizer">, + MarshallingInfoStringInt<"LangOpts->SanitizeAddressFieldPadding">; +defm sanitize_address_use_after_scope : BoolOption<"sanitize-address-use-after-scope", + "CodeGenOpts.SanitizeAddressUseAfterScope", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [CoreOption, NoXarchOption], "Disable">, + BothFlags<[], " use-after-scope detection in AddressSanitizer">, "f">, + Group<f_clang_Group>; +defm sanitize_address_poison_custom_array_cookie : BoolOption<"sanitize-address-poison-custom-array-cookie", + "CodeGenOpts.SanitizeAddressPoisonCustomArrayCookie", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [], "Disable">, + BothFlags<[], " poisoning array cookies when using custom operator new[] in AddressSanitizer">, "f">, + Group<f_clang_Group>; def fsanitize_address_globals_dead_stripping : Flag<["-"], "fsanitize-address-globals-dead-stripping">, - Group<f_clang_Group>, - HelpText<"Enable linker dead stripping of globals in AddressSanitizer">; -def fsanitize_address_use_odr_indicator - : Flag<["-"], "fsanitize-address-use-odr-indicator">, - Group<f_clang_Group>, - HelpText<"Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size">; -def fno_sanitize_address_use_odr_indicator - : Flag<["-"], "fno-sanitize-address-use-odr-indicator">, - Group<f_clang_Group>, - HelpText<"Disable ODR indicator globals">; + Group<f_clang_Group>, HelpText<"Enable linker dead stripping of globals in AddressSanitizer">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeAddressGlobalsDeadStripping", "false">; +defm sanitize_address_use_odr_indicator : BoolOption<"sanitize-address-use-odr-indicator", + "CodeGenOpts.SanitizeAddressUseOdrIndicator", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable ODR indicator globals to avoid false ODR violation" + " reports in partially sanitized programs at the cost of an increase in binary size">, + ResetBy<NegFlag, [], "Disable ODR indicator globals">, BothFlags<[]>, "f">, + Group<f_clang_Group>; // Note: This flag was introduced when it was necessary to distinguish between // ABI for correct codegen. This is no longer needed, but the flag is // not removed since targeting either ABI will behave the same. @@ -1436,10 +1493,10 @@ def fsanitize_undefined_trap_on_error def fno_sanitize_undefined_trap_on_error : Flag<["-"], "fno-sanitize-undefined-trap-on-error">, Group<f_clang_Group>, Alias<fno_sanitize_trap_EQ>, AliasArgs<["undefined"]>; -def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">, - Group<f_clang_Group>; -def fno_sanitize_minimal_runtime : Flag<["-"], "fno-sanitize-minimal-runtime">, - Group<f_clang_Group>; +defm sanitize_minimal_runtime : BoolOption<"sanitize-minimal-runtime", + "CodeGenOpts.SanitizeMinimalRuntime", DefaultsToFalse, + ChangedBy<PosFlag>, ResetBy<NegFlag>, BothFlags<[]>, "f">, + Group<f_clang_Group>; def fsanitize_link_runtime : Flag<["-"], "fsanitize-link-runtime">, Group<f_clang_Group>; def fno_sanitize_link_runtime : Flag<["-"], "fno-sanitize-link-runtime">, @@ -1448,30 +1505,25 @@ def fsanitize_link_cxx_runtime : Flag<["-"], "fsanitize-link-c++-runtime">, Group<f_clang_Group>; def fno_sanitize_link_cxx_runtime : Flag<["-"], "fno-sanitize-link-c++-runtime">, Group<f_clang_Group>; -def fsanitize_cfi_cross_dso : Flag<["-"], "fsanitize-cfi-cross-dso">, - Group<f_clang_Group>, - HelpText<"Enable control flow integrity (CFI) checks for cross-DSO calls.">; -def fno_sanitize_cfi_cross_dso : Flag<["-"], "fno-sanitize-cfi-cross-dso">, - Flags<[CoreOption, NoXarchOption]>, - Group<f_clang_Group>, - HelpText<"Disable control flow integrity (CFI) checks for cross-DSO calls.">; +defm sanitize_cfi_cross_dso : BoolOption<"sanitize-cfi-cross-dso", + "CodeGenOpts.SanitizeCfiCrossDso", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [CoreOption, NoXarchOption], "Disable">, + BothFlags<[], " control flow integrity (CFI) checks for cross-DSO calls.">, "f">, + Group<f_clang_Group>; def fsanitize_cfi_icall_generalize_pointers : Flag<["-"], "fsanitize-cfi-icall-generalize-pointers">, Group<f_clang_Group>, - HelpText<"Generalize pointers in CFI indirect call type signature checks">; -def fsanitize_cfi_canonical_jump_tables : Flag<["-"], "fsanitize-cfi-canonical-jump-tables">, - Group<f_clang_Group>, - HelpText<"Make the jump table addresses canonical in the symbol table">; -def fno_sanitize_cfi_canonical_jump_tables : Flag<["-"], "fno-sanitize-cfi-canonical-jump-tables">, - Group<f_clang_Group>, - Flags<[CoreOption, NoXarchOption]>, - HelpText<"Do not make the jump table addresses canonical in the symbol table">; -def fsanitize_stats : Flag<["-"], "fsanitize-stats">, - Group<f_clang_Group>, - HelpText<"Enable sanitizer statistics gathering.">; -def fno_sanitize_stats : Flag<["-"], "fno-sanitize-stats">, - Group<f_clang_Group>, - Flags<[CoreOption, NoXarchOption]>, - HelpText<"Disable sanitizer statistics gathering.">; + HelpText<"Generalize pointers in CFI indirect call type signature checks">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiICallGeneralizePointers">; +defm sanitize_cfi_canonical_jump_tables : BoolOption<"sanitize-cfi-canonical-jump-tables", + "CodeGenOpts.SanitizeCfiCanonicalJumpTables", DefaultsToFalse, + ChangedBy<PosFlag, [], "Make">, ResetBy<NegFlag, [CoreOption, NoXarchOption], "Do not make">, + BothFlags<[], " the jump table addresses canonical in the symbol table">, "f">, + Group<f_clang_Group>; +defm sanitize_stats : BoolOption<"sanitize-stats", + "CodeGenOpts.SanitizeStats", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [CoreOption, NoXarchOption], "Disable">, + BothFlags<[], " sanitizer statistics gathering.">, "f">, + Group<f_clang_Group>; def fsanitize_thread_memory_access : Flag<["-"], "fsanitize-thread-memory-access">, Group<f_clang_Group>, HelpText<"Enable memory access instrumentation in ThreadSanitizer (default)">; @@ -1496,7 +1548,8 @@ def fno_sanitize_thread_atomics : Flag<["-"], "fno-sanitize-thread-atomics">, def fsanitize_undefined_strip_path_components_EQ : Joined<["-"], "fsanitize-undefined-strip-path-components=">, Group<f_clang_Group>, MetaVarName<"<number>">, HelpText<"Strip (or keep only, if negative) a given number of path components " - "when emitting check metadata.">; + "when emitting check metadata.">, + MarshallingInfoStringInt<"CodeGenOpts.EmitCheckPathComponentsToStrip", "0", "int">; } // end -f[no-]sanitize* flags @@ -1524,7 +1577,9 @@ def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, 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>, Flags<[CC1Option]>; +def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option]>, + MarshallingInfoFlag<"LangOpts->FPRoundingMode", "llvm::RoundingMode::NearestTiesToEven">, + Normalizer<"makeFlagToValueNormalizer(llvm::RoundingMode::Dynamic)">; def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>, Flags<[CC1Option]>; def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>, Flags<[CC1Option]>; def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>, Flags<[CC1Option]>; @@ -1537,9 +1592,11 @@ def ffp_contract : Joined<["-"], "ffp-contract=">, Group<f_Group>, " Default is 'fast' for CUDA, 'fast-honor-pragmas' for HIP, and 'on' otherwise.">, Values<"fast,on,off,fast-honor-pragmas">; -defm strict_float_cast_overflow : OptOutFFlag<"strict-float-cast-overflow", - "Assume that overflowing float-to-int casts are undefined (default)", - "Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions">; +defm strict_float_cast_overflow : BoolFOption<"strict-float-cast-overflow", + "CodeGenOpts.StrictFloatCastOverflow", DefaultsToTrue, + ChangedBy<NegFlag, [], "Relax language rules and try to match the behavior" + " of the target's native float-to-int conversion instructions">, + ResetBy<PosFlag, [], "Assume that overflowing float-to-int casts are undefined (default)">>; def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>; def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>; @@ -1551,10 +1608,11 @@ defm rewrite_includes : BoolFOption<"rewrite-includes", "PreprocessorOutputOpts.RewriteIncludes", DefaultsToFalse, ChangedBy<PosFlag>, ResetBy<NegFlag>>; -defm delete_null_pointer_checks : OptOutFFlag<"delete-null-pointer-checks", - "Treat usage of null pointers as undefined behavior (default)", - "Do not treat usage of null pointers as undefined behavior", - "", [CoreOption]>; +defm delete_null_pointer_checks : BoolFOption<"delete-null-pointer-checks", + "CodeGenOpts.NullPointerIsValid", DefaultsToFalse, + ChangedBy<NegFlag, [], "Do not treat usage of null pointers as undefined behavior">, + ResetBy<PosFlag, [], "Treat usage of null pointers as undefined behavior (default)">, + BothFlags<[CoreOption]>>; def frewrite_map_file : Separate<["-"], "frewrite-map-file">, Group<f_Group>, @@ -1568,7 +1626,8 @@ defm use_line_directives : BoolFOption<"use-line-directives", ChangedBy<PosFlag, [], "Use #line in preprocessed output">, ResetBy<NegFlag>>; def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Assert that the compilation takes place in a freestanding environment">; + HelpText<"Assert that the compilation takes place in a freestanding environment">, + MarshallingInfoFlag<"LangOpts->Freestanding">; def fgnuc_version_EQ : Joined<["-"], "fgnuc-version=">, Group<f_Group>, HelpText<"Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)">, Flags<[CC1Option, CoreOption]>; @@ -1577,7 +1636,8 @@ def fgnu_keywords : Flag<["-"], "fgnu-keywords">, Group<f_Group>, Flags<[CC1Opti defm gnu89_inline : OptInFFlag<"gnu89-inline", "Use the gnu89 inline semantics">; 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 fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>, + MarshallingInfoFlag<"LangOpts->HeinousExtensions">; def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>, Group<Link_Group>; def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>; @@ -1606,11 +1666,14 @@ def fexperimental_strict_floating_point : Flag<["-"], "fexperimental-strict-floa def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>; def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>; def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Generate calls to instrument function entry and exit">; + HelpText<"Generate calls to instrument function entry and exit">, + MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctions">; def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Like -finstrument-functions, but insert the calls after inlining">; + HelpText<"Like -finstrument-functions, but insert the calls after inlining">, + MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionsAfterInlining">; def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">; + HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">, + MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionEntryBare">; def fcf_protection_EQ : Joined<["-"], "fcf-protection=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>, HelpText<"Instrument control-flow architecture protection. Options: return, branch, full, none.">, Values<"return,branch,full,none">; def fcf_protection : Flag<["-"], "fcf-protection">, Group<f_Group>, Flags<[CoreOption, CC1Option]>, @@ -1622,7 +1685,8 @@ defm xray_instrument : OptInFFlag<"xray-instrument", "Generate XRay instrumentat def fxray_instruction_threshold_EQ : JoinedOrSeparate<["-"], "fxray-instruction-threshold=">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Sets the minimum function size to instrument with XRay">; + HelpText<"Sets the minimum function size to instrument with XRay">, + MarshallingInfoStringInt<"CodeGenOpts.XRayInstructionThreshold", "200">; def fxray_instruction_threshold_ : JoinedOrSeparate<["-"], "fxray-instruction-threshold">, Group<f_Group>, Flags<[CC1Option]>; @@ -1677,23 +1741,24 @@ def fxray_selected_function_group : HelpText<"When using -fxray-function-groups, select which group of functions to instrument. Valid range is 0 to fxray-function-groups - 1">; -def ffine_grained_bitfield_accesses : Flag<["-"], - "ffine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>, - HelpText<"Use separate accesses for consecutive bitfield runs with legal widths and alignments.">; -def fno_fine_grained_bitfield_accesses : Flag<["-"], - "fno-fine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>, - HelpText<"Use large-integer access for consecutive bitfield runs.">; +defm fine_grained_bitfield_accesses : BoolOption<"fine-grained-bitfield-accesses", + "CodeGenOpts.FineGrainedBitfieldAccesses", DefaultsToFalse, + ChangedBy<PosFlag, [], "Use separate accesses for consecutive bitfield runs with legal widths and alignments.">, + ResetBy<NegFlag, [], "Use large-integer access for consecutive bitfield runs.">, + BothFlags<[CC1Option]>, "f">, + Group<f_clang_Group>; -def fexperimental_relative_cxx_abi_vtables : Flag<["-"], "fexperimental-relative-c++-abi-vtables">, - Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Use the experimental C++ class ABI for classes with virtual tables">; -def fno_experimental_relative_cxx_abi_vtables : Flag<["-"], "fno-experimental-relative-c++-abi-vtables">, - Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Do not use the experimental C++ class ABI for classes with virtual tables">; +defm experimental_relative_cxx_abi_vtables : BoolFOption<"experimental-relative-c++-abi-vtables", + "LangOpts->RelativeCXXABIVTables", DefaultsToFalse, + ChangedBy<PosFlag, [], "Use">, ResetBy<NegFlag, [], "Do not use">, + BothFlags<[CC1Option], " the experimental C++ class ABI for classes with virtual tables">>; def flat__namespace : Flag<["-"], "flat_namespace">; def flax_vector_conversions_EQ : Joined<["-"], "flax-vector-conversions=">, Group<f_Group>, - HelpText<"Enable implicit vector bit-casts">, Values<"none,integer,all">, Flags<[CC1Option]>; + HelpText<"Enable implicit vector bit-casts">, Values<"none,integer,all">, Flags<[CC1Option]>, + NormalizedValuesScope<"LangOptions::LaxVectorConversionKind">, + NormalizedValues<["None", "Integer", "All"]>, + MarshallingInfoString<"LangOpts->LaxVectorConversions", "All">, AutoNormalizeEnum; 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>; @@ -1715,18 +1780,23 @@ def fthinlto_index_EQ : Joined<["-"], "fthinlto-index=">, HelpText<"Perform ThinLTO importing using provided function summary index">; def fthin_link_bitcode_EQ : Joined<["-"], "fthin-link-bitcode=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>, - HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">; + HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">, + MarshallingInfoString<"CodeGenOpts.ThinLinkBitcodeFile">; def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">, Group<f_Group>, Flags<[NoXarchOption, CoreOption]>; -def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>, - Flags<[CC1Option, CoreOption]>, HelpText<"Allow merging of constants">; +defm merge_all_constants : BoolFOption<"merge-all-constants", + "CodeGenOpts.MergeAllConstants", DefaultsToFalse, + ChangedBy<PosFlag, [CoreOption], "Allow">, ResetBy<NegFlag, [], "Disallow">, + BothFlags<[], " merging of constants">>; def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Format message diagnostics so that they fit within N columns">; def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">; def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, - HelpText<"Enable full Microsoft Visual C++ compatibility">; -def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>; + HelpText<"Enable full Microsoft Visual C++ compatibility">, + MarshallingInfoFlag<"LangOpts->MSVCCompat">; +def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>, + MarshallingInfoFlag<"CodeGenOpts.MSVolatile">; def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[NoXarchOption, CoreOption]>, HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">; def fms_compatibility_version @@ -1736,10 +1806,17 @@ def fms_compatibility_version HelpText<"Dot-separated value representing the Microsoft compiler " "version number to report in _MSC_VER (0 = don't define it " "(default))">; -def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>, - HelpText<"Parse templated function definitions at the end of the " - "translation unit">, Flags<[CC1Option, CoreOption]>; -def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>; +defm delayed_template_parsing : BoolFOption<"delayed-template-parsing", + "LangOpts->DelayedTemplateParsing", DefaultsToFalse, + ChangedBy<PosFlag, [], "Parse templated function definitions at the end of the translation unit">, + ResetBy<NegFlag, [NoXarchOption], "Disable delayed template parsing">, + BothFlags<[CoreOption]>>; +def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>, + Values<"single,multiple,virtual">, NormalizedValuesScope<"LangOptions">, + NormalizedValues<["PPTMK_FullGeneralitySingleInheritance", "PPTMK_FullGeneralityMultipleInheritance", + "PPTMK_FullGeneralityVirtualInheritance"]>, + MarshallingInfoString<"LangOpts->MSPointerToMemberRepresentationMethod", "PPTMK_BestCase">, + AutoNormalizeEnum; def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>, Flags<[NoXarchOption, CC1Option]>, MetaVarName<"<directory>">, HelpText<"Specify the module cache path">; @@ -1779,7 +1856,7 @@ def fmodules_validate_once_per_build_session : Flag<["-"], "fmodules-validate-on def fmodules_disable_diagnostic_validation : Flag<["-"], "fmodules-disable-diagnostic-validation">, Group<i_Group>, Flags<[CC1Option]>, HelpText<"Disable validation of the diagnostic options when loading the module">, - MarshallingInfoFlag<"HeaderSearchOpts->ModulesValidateDiagnosticOptions", "true">, IsNegative; + MarshallingInfoNegativeFlag<"HeaderSearchOpts->ModulesValidateDiagnosticOptions">; defm modules_validate_system_headers : BoolOption<"modules-validate-system-headers", "HeaderSearchOpts->ModulesValidateSystemHeaders", DefaultsToFalse, ChangedBy<PosFlag, [CC1Option], "Validate the system headers that a module depends on when loading the module">, @@ -1806,13 +1883,10 @@ def fpch_validate_input_files_content: def fno_pch_validate_input_files_content: Flag <["-"], "fno_pch-validate-input-files-content">, Group<f_Group>, Flags<[NoXarchOption]>; -def fpch_instantiate_templates: - Flag <["-"], "fpch-instantiate-templates">, - Group<f_Group>, Flags<[CC1Option, CoreOption]>, - HelpText<"Instantiate templates already while building a PCH">; -def fno_pch_instantiate_templates: - Flag <["-"], "fno-pch-instantiate-templates">, - Group<f_Group>, Flags<[CC1Option, CoreOption]>; +defm pch_instantiate_templates : BoolFOption<"pch-instantiate-templates", + "LangOpts->PCHInstantiateTemplates", DefaultsToFalse, + ChangedBy<PosFlag, [], "Instantiate templates already while building a PCH">, + ResetBy<NegFlag>, BothFlags<[CC1Option, CoreOption]>>; defm pch_codegen: OptInFFlag<"pch-codegen", "Generate ", "Do not generate ", "code for uses of this PCH that assumes an explicit object file will be built for the PCH">; defm pch_debuginfo: OptInFFlag<"pch-debuginfo", "Generate ", "Do not generate ", @@ -1826,11 +1900,13 @@ def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<f_Group HelpText<"Implicitly search the file system for module map files.">, MarshallingInfoFlag<"HeaderSearchOpts->ImplicitModuleMaps">; def fmodules_ts : Flag <["-"], "fmodules-ts">, Group<f_Group>, - Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">; + Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">, + MarshallingInfoFlag<"LangOpts->ModulesTS">; def fmodule_maps : Flag <["-"], "fmodule-maps">, Alias<fimplicit_module_maps>; def fmodule_name_EQ : Joined<["-"], "fmodule-name=">, Group<f_Group>, Flags<[NoXarchOption,CC1Option]>, MetaVarName<"<name>">, - HelpText<"Specify the name of the module to build">; + HelpText<"Specify the name of the module to build">, + MarshallingInfoString<"LangOpts->ModuleName">; def fmodule_name : Separate<["-"], "fmodule-name">, Alias<fmodule_name_EQ>; def fmodule_implementation_of : Separate<["-"], "fmodule-implementation-of">, Flags<[CC1Option]>, Alias<fmodule_name_EQ>; @@ -1839,7 +1915,8 @@ def fsystem_module : Flag<["-"], "fsystem-module">, Flags<[CC1Option]>, MarshallingInfoFlag<"FrontendOpts.IsSystemModule">; def fmodule_map_file : Joined<["-"], "fmodule-map-file=">, Group<f_Group>, Flags<[NoXarchOption,CC1Option]>, MetaVarName<"<file>">, - HelpText<"Load this module map file">; + HelpText<"Load this module map file">, + MarshallingInfoStringVector<"FrontendOpts.ModuleMapFiles">; def fmodule_file : Joined<["-"], "fmodule-file=">, Group<i_Group>, Flags<[NoXarchOption,CC1Option]>, MetaVarName<"[<name>=]<file>">, HelpText<"Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.">; @@ -1850,25 +1927,25 @@ def fmodules_decluse : Flag <["-"], "fmodules-decluse">, Group<f_Group>, HelpText<"Require declaration of modules used within a module">; def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_Group>, Flags<[NoXarchOption,CC1Option]>, - HelpText<"Like -fmodules-decluse but requires all headers to be in modules">; + HelpText<"Like -fmodules-decluse but requires all headers to be in modules">, + MarshallingInfoFlag<"LangOpts->ModulesStrictDeclUse">; def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>, Flags<[NoXarchOption, CC1Option]>; -def fno_implicit_modules : - Flag <["-"], "fno-implicit-modules">, - Group<f_Group>, Flags<[NoXarchOption, CC1Option]>; -def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>; +defm implicit_modules : BoolFOption<"implicit-modules", + "LangOpts->ImplicitModules", DefaultsToTrue, + ChangedBy<NegFlag>, ResetBy<PosFlag>, BothFlags<[NoXarchOption]>>; +def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>, + MarshallingInfoFlag<"LangOpts->RetainCommentsFromSystemHeaders">; def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>; def fmudflap : Flag<["-"], "fmudflap">, Group<f_Group>; def fnested_functions : Flag<["-"], "fnested-functions">, Group<f_Group>; def fnext_runtime : Flag<["-"], "fnext-runtime">, Group<f_Group>; -def fno_apple_pragma_pack : Flag<["-"], "fno-apple-pragma-pack">, Group<f_Group>; def fno_asm : Flag<["-"], "fno-asm">, Group<f_Group>; def fno_asynchronous_unwind_tables : Flag<["-"], "fno-asynchronous-unwind-tables">, Group<f_Group>; def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group<f_Group>, HelpText<"Don't assume that C++'s global operator new can't alias any pointer">, - Flags<[CC1Option]>; -def fno_borland_extensions : Flag<["-"], "fno-borland-extensions">, Group<f_Group>; + Flags<[CC1Option]>, MarshallingInfoNegativeFlag<"CodeGenOpts.AssumeSaneOperatorNew">; def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, HelpText<"Disable implicit builtin knowledge of functions">; def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, @@ -1877,14 +1954,10 @@ def fno_diagnostics_color : Flag<["-"], "fno-diagnostics-color">, Group<f_Group> Flags<[CoreOption, NoXarchOption]>; def fno_common : Flag<["-"], "fno-common">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Compile common globals like normal definitions">; -def fno_constant_cfstrings : Flag<["-"], "fno-constant-cfstrings">, Group<f_Group>, - Flags<[CC1Option]>, - HelpText<"Disable creation of CodeFoundation-type constant strings">; def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>, Flags<[NoXarchOption]>; def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">; -def fno_diagnostics_show_hotness : Flag<["-"], "fno-diagnostics-show-hotness">, Group<f_Group>; def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group<f_Group>, Flags<[CC1Option]>; def fno_diagnostics_show_note_include_stack : Flag<["-"], "fno-diagnostics-show-note-include-stack">, Flags<[CC1Option]>, Group<f_Group>; @@ -1896,8 +1969,6 @@ def fno_declspec : Flag<["-"], "fno-declspec">, Group<f_clang_Group>, HelpText<"Disallow __declspec as a keyword">, Flags<[CC1Option]>; 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_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]>; @@ -1907,11 +1978,13 @@ def fno_global_isel : Flag<["-"], "fno-global-isel">, Group<f_clang_Group>, def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>, Alias<fno_global_isel>; def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Use the given vector functions library">, Values<"Accelerate,libmvec,MASSV,SVML,none">; + HelpText<"Use the given vector functions library">, + Values<"Accelerate,libmvec,MASSV,SVML,none">, + NormalizedValuesScope<"CodeGenOptions">, + NormalizedValues<["Accelerate", "LIBMVEC", "MASSV", "SVML", "NoLibrary"]>, + MarshallingInfoString<"CodeGenOpts.VecLib", "NoLibrary">, AutoNormalizeEnum; def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>, Alias<flax_vector_conversions_EQ>, AliasArgs<["none"]>; -def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>, - HelpText<"Disallow merging of constants">; def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>, Flags<[NoXarchOption]>; def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>, @@ -1921,8 +1994,6 @@ def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>, Flags<[NoXarchOption]>; def fno_modules_strict_decluse : Flag <["-"], "fno-strict-modules-decluse">, Group<f_Group>, Flags<[NoXarchOption]>; -def fimplicit_modules : Flag <["-"], "fimplicit-modules">, Group<f_Group>, - Flags<[NoXarchOption]>; def fmodule_file_deps : Flag <["-"], "fmodule-file-deps">, Group<f_Group>, Flags<[NoXarchOption]>; def fno_module_file_deps : Flag <["-"], "fno-module-file-deps">, Group<f_Group>, @@ -1931,24 +2002,16 @@ def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>, Flags<[CoreOption]>; def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>, Flags<[CoreOption]>; -def fno_delayed_template_parsing : Flag<["-"], "fno-delayed-template-parsing">, Group<f_Group>, - HelpText<"Disable delayed template parsing">, - Flags<[NoXarchOption, CoreOption]>; -def fno_objc_exceptions: Flag<["-"], "fno-objc-exceptions">, Group<f_Group>; def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>; def fno_objc_weak : Flag<["-"], "fno-objc-weak">, Group<f_Group>, Flags<[CC1Option]>; def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>; def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>, HelpText<"Do not treat C++ operator name keywords as synonyms for operators">, Flags<[CC1Option]>; -def fno_pascal_strings : Flag<["-"], "fno-pascal-strings">, Group<f_Group>; -def fno_short_enums : Flag<["-"], "fno-short-enums">, Group<f_Group>; def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">; def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">; -def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>, - Flags<[CC1Option]>, HelpText<"Disable spell-checking">; def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>, HelpText<"Disable the use of stack protectors">; def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>, @@ -1956,58 +2019,55 @@ def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>, def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>; def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>; def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>; -def fno_strict_vtable_pointers: Flag<["-"], "fno-strict-vtable-pointers">, - Group<f_Group>; def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>; def fno_temp_file : Flag<["-"], "fno-temp-file">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, HelpText< "Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes">, - MarshallingInfoFlag<"FrontendOpts.UseTemporary", "true">, IsNegative; -def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group<f_Group>, - Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">; -def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Don't use __cxa_atexit for calling destructors">; -def fno_register_global_dtors_with_atexit : Flag<["-"], "fno-register-global-dtors-with-atexit">, Group<f_Group>, - HelpText<"Don't use atexit or __cxa_atexit to register global destructors">; + MarshallingInfoNegativeFlag<"FrontendOpts.UseTemporary">; +defm use_cxa_atexit : BoolFOption<"use-cxa-atexit", + "CodeGenOpts.CXAAtExit", DefaultsToTrue, + ChangedBy<NegFlag, [], "Don't use __cxa_atexit for calling destructors">, + ResetBy<PosFlag>>; def fno_unit_at_a_time : Flag<["-"], "fno-unit-at-a-time">, Group<f_Group>; def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>; -def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>, Flags<[CC1Option]>; +def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>, Flags<[CC1Option]>, + MarshallingInfoNegativeFlag<"CodeGenOpts.AsmVerbose">; def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>; def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>; def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Synthesize retain and release calls for Objective-C pointers">; def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>; -def fobjc_convert_messages_to_runtime_calls : - Flag<["-"], "fobjc-convert-messages-to-runtime-calls">, Group<f_Group>; -def fno_objc_convert_messages_to_runtime_calls : - Flag<["-"], "fno-objc-convert-messages-to-runtime-calls">, Group<f_Group>, Flags<[CC1Option]>; -def fobjc_arc_exceptions : Flag<["-"], "fobjc-arc-exceptions">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Use EH-safe code when synthesizing retains and releases in -fobjc-arc">; -def fno_objc_arc_exceptions : Flag<["-"], "fno-objc-arc-exceptions">, Group<f_Group>; +defm objc_convert_messages_to_runtime_calls : BoolFOption<"objc-convert-messages-to-runtime-calls", + "CodeGenOpts.ObjCConvertMessagesToRuntimeCalls", DefaultsToTrue, + ChangedBy<NegFlag>, ResetBy<PosFlag>>; +defm objc_arc_exceptions : OptInFFlag<"objc-arc-exceptions", + "Use EH-safe code when synthesizing retains and releases in -fobjc-arc", + "", "", [], "CodeGenOpts.ObjCAutoRefCountExceptions">; def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>; def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>; -def fobjc_exceptions: Flag<["-"], "fobjc-exceptions">, Group<f_Group>, - HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>; -def fapplication_extension : Flag<["-"], "fapplication-extension">, - Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Restrict code to those available for App Extensions">; -def fno_application_extension : Flag<["-"], "fno-application-extension">, - Group<f_Group>; -def frelaxed_template_template_args : Flag<["-"], "frelaxed-template-template-args">, - Flags<[CC1Option]>, HelpText<"Enable C++17 relaxed template template argument matching">, - Group<f_Group>; -def fno_relaxed_template_template_args : Flag<["-"], "fno-relaxed-template-template-args">, - Group<f_Group>; -def fsized_deallocation : Flag<["-"], "fsized-deallocation">, Flags<[CC1Option]>, - HelpText<"Enable C++14 sized global deallocation functions">, Group<f_Group>; -def fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">, Group<f_Group>; +defm objc_exceptions : BoolFOption<"objc-exceptions", + "LangOpts->ObjCExceptions", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable Objective-C exceptions">, ResetBy<NegFlag>>; +defm application_extension : BoolFOption<"application-extension", + "LangOpts->AppExt", DefaultsToFalse, + ChangedBy<PosFlag, [], "Restrict code to those available for App Extensions">, + ResetBy<NegFlag>>; +defm relaxed_template_template_args : BoolFOption<"relaxed-template-template-args", + "LangOpts->RelaxedTemplateTemplateArgs", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable C++17 relaxed template template argument matching">, + ResetBy<NegFlag>>; +defm sized_deallocation : BoolFOption<"sized-deallocation", + "LangOpts->SizedDeallocation", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable C++14 sized global deallocation functions">, + ResetBy<NegFlag>>; def faligned_allocation : Flag<["-"], "faligned-allocation">, Flags<[CC1Option]>, HelpText<"Enable C++17 aligned allocation functions">, Group<f_Group>; def fno_aligned_allocation: Flag<["-"], "fno-aligned-allocation">, Group<f_Group>, Flags<[CC1Option]>; def fnew_alignment_EQ : Joined<["-"], "fnew-alignment=">, HelpText<"Specifies the largest alignment guaranteed by '::operator new(size_t)'">, - MetaVarName<"<align>">, Group<f_Group>, Flags<[CC1Option]>; + MetaVarName<"<align>">, Group<f_Group>, Flags<[CC1Option]>, + MarshallingInfoStringInt<"LangOpts->NewAlignOverride">; def : Separate<["-"], "fnew-alignment">, Alias<fnew_alignment_EQ>; def : Flag<["-"], "faligned-new">, Alias<faligned_allocation>; def : Flag<["-"], "fno-aligned-new">, Alias<fno_aligned_allocation>; @@ -2015,13 +2075,10 @@ def faligned_new_EQ : Joined<["-"], "faligned-new=">; def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>; def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>; -def fobjc_infer_related_result_type : Flag<["-"], "fobjc-infer-related-result-type">, - Group<f_Group>; -def fno_objc_infer_related_result_type : Flag<["-"], - "fno-objc-infer-related-result-type">, Group<f_Group>, - HelpText< - "do not infer Objective-C related result type based on method family">, - Flags<[CC1Option]>; +defm objc_infer_related_result_type : BoolFOption<"objc-infer-related-result-type", + "LangOpts->ObjCInferRelatedResultType", DefaultsToTrue, + ChangedBy<NegFlag, [], "do not infer Objective-C related result type based on method family">, + ResetBy<PosFlag>>; def fobjc_link_runtime: Flag<["-"], "fobjc-link-runtime">, Group<f_Group>; def fobjc_weak : Flag<["-"], "fobjc-weak">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Enable ARC-style weak references in Objective-C">; @@ -2037,7 +2094,8 @@ def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Gr def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>; def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>; def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>, - HelpText<"Parse OpenMP pragmas and generate parallel code.">; + HelpText<"Parse OpenMP pragmas and generate parallel code.">, + MarshallingInfoFlag<"LangOpts->OpenMP", "0u">, Normalizer<"makeFlagToValueNormalizer(50u)">; def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>; def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>; def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>; @@ -2070,10 +2128,9 @@ def fopenmp_cuda_blocks_per_sm_EQ : Joined<["-"], "fopenmp-cuda-blocks-per-sm="> Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; def fopenmp_cuda_teams_reduction_recs_num_EQ : Joined<["-"], "fopenmp-cuda-teams-reduction-recs-num=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; -def fopenmp_optimistic_collapse : Flag<["-"], "fopenmp-optimistic-collapse">, Group<f_Group>, - Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; -def fno_openmp_optimistic_collapse : Flag<["-"], "fno-openmp-optimistic-collapse">, Group<f_Group>, - Flags<[NoArgumentUnused, HelpHidden]>; +defm openmp_optimistic_collapse : BoolFOption<"openmp-optimistic-collapse", + "LangOpts->OpenMPOptimisticCollapse", DefaultsToFalse, + ChangedBy<PosFlag>, ResetBy<NegFlag>, BothFlags<[NoArgumentUnused, HelpHidden]>>; def fopenmp_cuda_parallel_target_regions : Flag<["-"], "fopenmp-cuda-parallel-target-regions">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>, HelpText<"Support parallel execution of target regions on Cuda-based devices.">; @@ -2084,8 +2141,9 @@ def static_openmp: Flag<["-"], "static-openmp">, HelpText<"Use the static host OpenMP runtime while linking.">; def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>; def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>; -def fno_escaping_block_tail_calls : Flag<["-"], "fno-escaping-block-tail-calls">, Group<f_Group>, Flags<[CC1Option]>; -def fescaping_block_tail_calls : Flag<["-"], "fescaping-block-tail-calls">, Group<f_Group>; +defm escaping_block_tail_calls : BoolFOption<"escaping-block-tail-calls", + "CodeGenOpts.NoEscapingBlockTailCalls", DefaultsToFalse, + ChangedBy<NegFlag>, ResetBy<PosFlag>>; def force__cpusubtype__ALL : Flag<["-"], "force_cpusubtype_ALL">; def force__flat__namespace : Flag<["-"], "force_flat_namespace">; def force__load : Separate<["-"], "force_load">; @@ -2094,14 +2152,22 @@ def foutput_class_dir_EQ : Joined<["-"], "foutput-class-dir=">, Group<f_Group>; def fpack_struct : Flag<["-"], "fpack-struct">, Group<f_Group>; def fno_pack_struct : Flag<["-"], "fno-pack-struct">, Group<f_Group>; def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Specify the default maximum struct packing alignment">; + HelpText<"Specify the default maximum struct packing alignment">, + MarshallingInfoStringInt<"LangOpts->PackStruct">; def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">; + HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">, + MarshallingInfoStringInt<"LangOpts->MaxTypeAlign">; def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>; -def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Recognize and construct Pascal-style string literals">; +defm pascal_strings : BoolFOption<"pascal-strings", + "LangOpts->PascalStrings", DefaultsToFalse, + ChangedBy<PosFlag, [], "Recognize and construct Pascal-style string literals">, + ResetBy<NegFlag>>; +// Note: This flag has different semantics in the driver and in -cc1. The driver accepts -fpatchable-function-entry=M,N +// and forwards it to -cc1 as -fpatchable-function-entry=M and -fpatchable-function-entry-offset=N. In -cc1, both flags +// are treated as a single integer. def fpatchable_function_entry_EQ : Joined<["-"], "fpatchable-function-entry=">, Group<f_Group>, Flags<[CC1Option]>, - MetaVarName<"<N,M>">, HelpText<"Generate M NOPs before function entry and N-M NOPs after function entry">; + MetaVarName<"<N,M>">, HelpText<"Generate M NOPs before function entry and N-M NOPs after function entry">, + MarshallingInfoStringInt<"CodeGenOpts.PatchableFunctionEntryCount">; def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Override the default ABI to return all structs on the stack">; def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>; @@ -2109,19 +2175,30 @@ 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>; -defm plt : OptOutFFlag<"plt", "", - "Use GOT indirection instead of PLT to make external function calls (x86 only)">; -defm ropi : OptInFFlag<"ropi", "Generate read-only position independent code (ARM only)">; -defm rwpi : OptInFFlag<"rwpi", "Generate read-write position independent code (ARM only)">; +defm plt : BoolFOption<"plt", + "CodeGenOpts.NoPLT", DefaultsToFalse, + ChangedBy<NegFlag, [], "Use GOT indirection instead of PLT to make external function calls (x86 only)">, + ResetBy<PosFlag>>; +defm ropi : BoolFOption<"ropi", + "LangOpts->ROPI", DefaultsToFalse, + ChangedBy<PosFlag, [], "Generate read-only position independent code (ARM only)">, + ResetBy<NegFlag>>; +defm rwpi : BoolFOption<"rwpi", + "LangOpts->RWPI", DefaultsToFalse, + ChangedBy<PosFlag, [], "Generate read-write position independent code (ARM only)">, + ResetBy<NegFlag>>; def fplugin_EQ : Joined<["-"], "fplugin=">, Group<f_Group>, Flags<[NoXarchOption]>, MetaVarName<"<dsopath>">, HelpText<"Load the named plugin (dynamic shared object)">; def fpass_plugin_EQ : Joined<["-"], "fpass-plugin=">, Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<dsopath>">, HelpText<"Load pass plugin from a dynamic shared object file (only with new pass manager).">; -defm preserve_as_comments : OptOutFFlag<"preserve-as-comments", "", - "Do not preserve comments in inline assembly">; -def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>, Flags<[CC1Option,LinkOption]>; -def fno_profile_arcs : Flag<["-"], "fno-profile-arcs">, Group<f_Group>; +defm preserve_as_comments : BoolFOption<"preserve-as-comments", + "CodeGenOpts.PreserveAsmComments", DefaultsToTrue, + ChangedBy<NegFlag, [], "Do not preserve comments in inline assembly">, + ResetBy<PosFlag>>; +defm profile_arcs : BoolFOption<"profile-arcs", + "CodeGenOpts.EmitGcovArcs", DefaultsToFalse, + ChangedBy<PosFlag, [LinkOption]>, ResetBy<NegFlag>>; 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]>, @@ -2129,8 +2206,11 @@ def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flag defm rtti : OptOutFFlag<"rtti", "", "Disable generation of rtti information">; defm rtti_data : OptOutFFlag<"rtti-data", "", "Disable generation of RTTI data">; 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">; +defm short_enums : BoolFOption<"short-enums", + "LangOpts->ShortEnums", DefaultsToFalse, + ChangedBy<PosFlag, [], "Allocate to an enum type only as many bytes as it" + " needs for the declared range of possible values">, + ResetBy<NegFlag>>; def fchar8__t : Flag<["-"], "fchar8_t">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Enable C++ builtin type char8_t">; def fno_char8__t : Flag<["-"], "fno-char8_t">, Group<f_Group>, Flags<[CC1Option]>, @@ -2144,17 +2224,19 @@ def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flag "best|all; defaults to all">, Values<"best,all">; defm show_column : OptOutFFlag<"show-column", "", "Do not include column number on diagnostics">; def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group>; -def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>; +defm spell_checking : BoolFOption<"spell-checking", + "LangOpts->SpellChecking", DefaultsToTrue, + ChangedBy<NegFlag, [], "Disable spell-checking">, ResetBy<PosFlag>>; def fspell_checking_limit_EQ : Joined<["-"], "fspell-checking-limit=">, Group<f_Group>; def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>; defm signed_char : OptOutFFlag<"signed-char", "char is signed", "char is unsigned">; def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>; def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>, HelpText<"Enable stack protectors for all functions">; -def fstack_clash_protection : Flag<["-"], "fstack-clash-protection">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Enable stack clash protection">; -def fno_stack_clash_protection : Flag<["-"], "fno-stack-clash-protection">, Group<f_Group>, - HelpText<"Disable stack clash protection">; +defm stack_clash_protection : BoolFOption<"stack-clash-protection", + "CodeGenOpts.StackClashProtector", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [], "Disable">, + BothFlags<[], " stack clash protection">>; def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>, HelpText<"Enable stack protectors for some functions vulnerable to stack smashing. " "Compared to -fstack-protector, this uses a stronger heuristic " @@ -2173,12 +2255,16 @@ def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>, "address. The reference stack guard value is stored in a global variable.">; def ftrivial_auto_var_init : Joined<["-"], "ftrivial-auto-var-init=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, HelpText<"Initialize trivial automatic stack variables: uninitialized (default)" - " | pattern">, Values<"uninitialized,pattern">; + " | pattern">, Values<"uninitialized,zero,pattern">, + NormalizedValuesScope<"LangOptions::TrivialAutoVarInitKind">, + NormalizedValues<["Uninitialized", "Zero", "Pattern"]>, + MarshallingInfoString<"LangOpts->TrivialAutoVarInit", "Uninitialized">, AutoNormalizeEnum; def enable_trivial_var_init_zero : Flag<["-"], "enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang">, Flags<[CC1Option, CoreOption]>, HelpText<"Trivial automatic variable initialization to zero is only here for benchmarks, it'll eventually be removed, and I'm OK with that because I'm only using it to benchmark">; def ftrivial_auto_var_init_stop_after : Joined<["-"], "ftrivial-auto-var-init-stop-after=">, Group<f_Group>, - Flags<[CC1Option, CoreOption]>, HelpText<"Stop initializing trivial automatic stack variables after the specified number of instances">; + Flags<[CC1Option, CoreOption]>, HelpText<"Stop initializing trivial automatic stack variables after the specified number of instances">, + MarshallingInfoStringInt<"LangOpts->TrivialAutoVarInitStopAfter">; def fstandalone_debug : Flag<["-"], "fstandalone-debug">, Group<f_Group>, Flags<[CoreOption]>, HelpText<"Emit full debug info for all types used by the program">; def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>, Flags<[CoreOption]>, @@ -2193,11 +2279,13 @@ def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>, Flags<[NoXarchOption, CoreOption]>; def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Enable optimizations based on the strict definition of an enum's " - "value range">; -def fstrict_vtable_pointers: Flag<["-"], "fstrict-vtable-pointers">, - Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Enable optimizations based on the strict rules for overwriting " - "polymorphic C++ objects">; + "value range">, + MarshallingInfoFlag<"CodeGenOpts.StrictEnums">; +defm strict_vtable_pointers : BoolFOption<"strict-vtable-pointers", + "CodeGenOpts.StrictVTablePointers", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable optimizations based on the strict rules for" + " overwriting polymorphic C++ objects">, + ResetBy<NegFlag>>; def fstrict_overflow : Flag<["-"], "fstrict-overflow">, Group<f_Group>; def fsyntax_only : Flag<["-"], "fsyntax-only">, Flags<[NoXarchOption,CoreOption,CC1Option,FC1Option]>, Group<Action_Group>; @@ -2225,8 +2313,9 @@ def foptimization_record_passes_EQ : Joined<["-"], "foptimization-record-passes= HelpText<"Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)">, MetaVarName<"<regex>">; -def ftest_coverage : Flag<["-"], "ftest-coverage">, Flags<[CC1Option]>, Group<f_Group>; -def fno_test_coverage : Flag<["-"], "fno-test-coverage">, Group<f_Group>; +defm test_coverage : BoolFOption<"test-coverage", + "CodeGenOpts.EmitGcovNotes", DefaultsToFalse, + ChangedBy<PosFlag>, ResetBy<NegFlag>>; def fvectorize : Flag<["-"], "fvectorize">, Group<f_Group>, HelpText<"Enable the loop vectorization passes">; def fno_vectorize : Flag<["-"], "fno-vectorize">, Group<f_Group>; @@ -2240,7 +2329,8 @@ def : Flag<["-"], "fno-tree-slp-vectorize">, Alias<fno_slp_vectorize>; def Wlarge_by_value_copy_def : Flag<["-"], "Wlarge-by-value-copy">, HelpText<"Warn if a function definition returns or accepts an object larger " "in bytes than a given value">, Flags<[HelpHidden]>; -def Wlarge_by_value_copy_EQ : Joined<["-"], "Wlarge-by-value-copy=">, Flags<[CC1Option]>; +def Wlarge_by_value_copy_EQ : Joined<["-"], "Wlarge-by-value-copy=">, Flags<[CC1Option]>, + MarshallingInfoStringInt<"LangOpts->NumLargeByValueCopy">; // These "special" warning flags are effectively processed as f_Group flags by the driver: // Just silence warnings about -Wlarger-than for now. @@ -2249,7 +2339,10 @@ def Wlarger_than_ : Joined<["-"], "Wlarger-than-">, Alias<Wlarger_than_EQ>; def Wframe_larger_than_EQ : Joined<["-"], "Wframe-larger-than=">, Group<f_Group>, Flags<[NoXarchOption]>; def : Flag<["-"], "fterminated-vtables">, Alias<fapple_kext>; -def fthreadsafe_statics : Flag<["-"], "fthreadsafe-statics">, Group<f_Group>; +defm threadsafe_statics : BoolFOption<"threadsafe-statics", + "LangOpts->ThreadsafeStatics", DefaultsToTrue, + ChangedBy<NegFlag, [], "Do not emit code to make initialization of local statics thread safe">, + ResetBy<PosFlag>>; def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>, MarshallingInfoFlag<"CodeGenOpts.TimePasses">; def ftime_report_EQ: Joined<["-"], "ftime-report=">, Group<f_Group>, @@ -2273,7 +2366,11 @@ def fproc_stat_report : Joined<["-"], "fproc-stat-report">, Group<f_Group>, HelpText<"Print subprocess statistics">; def fproc_stat_report_EQ : Joined<["-"], "fproc-stat-report=">, Group<f_Group>, HelpText<"Save subprocess statistics to the given file">; -def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>; +def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>, + Values<"global-dynamic,local-dynamic,initial-exec,local-exec">, + NormalizedValuesScope<"CodeGenOptions">, + NormalizedValues<["GeneralDynamicTLSModel", "LocalDynamicTLSModel", "InitialExecTLSModel", "LocalExecTLSModel"]>, + MarshallingInfoString<"CodeGenOpts.DefaultTLSModel", "GeneralDynamicTLSModel">, AutoNormalizeEnum; def ftrapv : Flag<["-"], "ftrapv">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Trap on integer overflow">; def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>, @@ -2281,13 +2378,16 @@ def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>, HelpText<"Specify the function to be called on overflow">; def ftrapv_handler : Separate<["-"], "ftrapv-handler">, Group<f_Group>, Flags<[CC1Option]>; def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Issue call to specified function rather than a trap instruction">; + HelpText<"Issue call to specified function rather than a trap instruction">, + MarshallingInfoString<"CodeGenOpts.TrapFuncName">; def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>; def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>, HelpText<"Turn on loop unroller">, Flags<[CC1Option]>; def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>, HelpText<"Turn off loop unroller">, Flags<[CC1Option]>; -defm reroll_loops : OptInFFlag<"reroll-loops", "Turn on loop reroller">; +defm reroll_loops : BoolFOption<"reroll-loops", + "CodeGenOpts.RerollLoops", DefaultsToFalse, + ChangedBy<PosFlag, [], "Turn on loop reroller">, ResetBy<NegFlag>>; def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>, HelpText<"Process trigraph sequences">, Flags<[CC1Option]>; def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>, @@ -2296,10 +2396,14 @@ def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>; def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>; def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">; def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>; -def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>; -def fregister_global_dtors_with_atexit : Flag<["-"], "fregister-global-dtors-with-atexit">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Use atexit or __cxa_atexit to register global destructors">; -defm use_init_array : OptOutFFlag<"use-init-array", "", "Use .ctors/.dtors instead of .init_array/.fini_array">; +defm register_global_dtors_with_atexit : BoolFOption<"register-global-dtors-with-atexit", + "CodeGenOpts.RegisterGlobalDtorsWithAtExit", DefaultsToFalse, + ChangedBy<PosFlag, [], "Use">, ResetBy<NegFlag, [], "Don't use">, + BothFlags<[], " atexit or __cxa_atexit to register global destructors">>; +defm use_init_array : BoolFOption<"use-init-array", + "CodeGenOpts.UseInitArray", DefaultsToTrue, + ChangedBy<NegFlag, [], "Use .ctors/.dtors instead of .init_array/.fini_array">, + ResetBy<PosFlag>>; def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>; def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>, HelpText<"Generate verbose assembly output">; @@ -2317,73 +2421,104 @@ def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>, HelpText<"Set the default symbol visibility for all global declarations">, Values<"hidden,default">; def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>, HelpText<"Give inline C++ member functions hidden visibility by default">, - Flags<[CC1Option]>; -def fvisibility_inlines_hidden_static_local_var : - Flag<["-"], "fvisibility-inlines-hidden-static-local-var">, Group<f_Group>, - HelpText<"When -fvisibility-inlines-hidden is enabled, static variables in " - "inline C++ member functions will also be given hidden visibility " - "by default">, - Flags<[CC1Option]>; -def fno_visibility_inlines_hidden_static_local_var : - Flag<["-"], "fno-visibility-inlines-hidden-static-local-var">, Group<f_Group>, - HelpText<"Disables -fvisibility-inlines-hidden-static-local-var " - "(this is the default on non-darwin targets)">, - Flags<[CC1Option]>; + Flags<[CC1Option]>, MarshallingInfoFlag<"LangOpts->InlineVisibilityHidden">; +defm visibility_inlines_hidden_static_local_var : BoolFOption<"visibility-inlines-hidden-static-local-var", + "LangOpts->VisibilityInlinesHiddenStaticLocalVar", DefaultsToFalse, + ChangedBy<PosFlag, [], "When -fvisibility-inlines-hidden is enabled, static variables in" + " inline C++ member functions will also be given hidden visibility by default">, + ResetBy<NegFlag, [], "Disables -fvisibility-inlines-hidden-static-local-var" + " (this is the default on non-darwin targets)">, BothFlags<[CC1Option]>>; def fvisibility_ms_compat : Flag<["-"], "fvisibility-ms-compat">, Group<f_Group>, HelpText<"Give global types 'default' visibility and global functions and " "variables 'hidden' visibility by default">; def fvisibility_global_new_delete_hidden : Flag<["-"], "fvisibility-global-new-delete-hidden">, Group<f_Group>, - HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>; -defm whole_program_vtables : OptInFFlag<"whole-program-vtables", - "Enables whole-program vtable optimization. Requires -flto", "", "", [CoreOption]>; -defm split_lto_unit : OptInFFlag<"split-lto-unit", - "Enables splitting of the LTO unit", "", "", [CoreOption]>; -defm force_emit_vtables : OptInFFlag<"force-emit-vtables", - "Emits more virtual tables to improve devirtualization", "", "", [CoreOption]>; -defm virtual_function_elimination : OptInFFlag<"virtual-function-elimination", - "Enables dead virtual function elimination optimization. Requires -flto=full", "", "", [CoreOption]>; + HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>, + MarshallingInfoFlag<"LangOpts->GlobalAllocationFunctionVisibilityHidden">; +defm whole_program_vtables : BoolFOption<"whole-program-vtables", + "CodeGenOpts.WholeProgramVTables", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enables whole-program vtable optimization. Requires -flto">, + ResetBy<NegFlag>, BothFlags<[CoreOption]>>; +defm split_lto_unit : BoolFOption<"split-lto-unit", + "CodeGenOpts.EnableSplitLTOUnit", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enables splitting of the LTO unit">, + ResetBy<NegFlag>, BothFlags<[CoreOption]>>; +defm force_emit_vtables : BoolFOption<"force-emit-vtables", + "CodeGenOpts.ForceEmitVTables", DefaultsToFalse, + ChangedBy<PosFlag, [], "Emits more virtual tables to improve devirtualization">, + ResetBy<NegFlag>, BothFlags<[CoreOption]>>; +defm virtual_function_elimination : BoolFOption<"virtual-function-elimination", + "CodeGenOpts.VirtualFunctionElimination", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enables dead virtual function elimination optimization. Requires -flto=full">, + ResetBy<NegFlag>, BothFlags<[CoreOption]>>; def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Treat signed integer overflow as two's complement">; def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Store string literals as writable data">; -defm zero_initialized_in_bss : OptOutFFlag<"zero-initialized-in-bss", "", "Don't place zero initialized data in BSS">; + HelpText<"Store string literals as writable data">, + MarshallingInfoFlag<"LangOpts->WritableStrings">; +defm zero_initialized_in_bss : BoolFOption<"zero-initialized-in-bss", + "CodeGenOpts.NoZeroInitializedInBSS", DefaultsToFalse, + ChangedBy<NegFlag, [], "Don't place zero initialized data in BSS">, + ResetBy<PosFlag>>; defm function_sections : OptInFFlag<"function-sections", "Place each function in its own section">; def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>, Flags<[CC1Option, CC1AsOption]>, HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">, DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>, - Values<"all,labels,none,list=">; -defm data_sections : OptInFFlag<"data-sections", "Place each data in its own section">; -defm stack_size_section : OptInFFlag<"stack-size-section", "Emit section containing metadata on function stack sizes">; - -defm unique_basic_block_section_names : OptInFFlag<"unique-basic-block-section-names", - "Use unique names for basic block sections (ELF Only)">; -defm unique_internal_linkage_names : OptInFFlag<"unique-internal-linkage-names", - "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path">; -defm unique_section_names : OptOutFFlag<"unique-section-names", - "", "Don't use unique names for text and data sections">; + Values<"all,labels,none,list=">, + MarshallingInfoString<"CodeGenOpts.BBSections", [{"none"}]>; +defm data_sections : BoolFOption<"data-sections", + "CodeGenOpts.DataSections", DefaultsToFalse, + ChangedBy<PosFlag, [], "Place each data in its own section">, ResetBy<NegFlag>>; +defm stack_size_section : BoolFOption<"stack-size-section", + "CodeGenOpts.StackSizeSection", DefaultsToFalse, + ChangedBy<PosFlag, [], "Emit section containing metadata on function stack sizes">, + ResetBy<NegFlag>>; + +defm unique_basic_block_section_names : BoolFOption<"unique-basic-block-section-names", + "CodeGenOpts.UniqueBasicBlockSectionNames", DefaultsToFalse, + ChangedBy<PosFlag, [], "Use unique names for basic block sections (ELF Only)">, + ResetBy<NegFlag>>; +defm unique_internal_linkage_names : BoolFOption<"unique-internal-linkage-names", + "CodeGenOpts.UniqueInternalLinkageNames", DefaultsToFalse, + ChangedBy<PosFlag, [], "Uniqueify Internal Linkage Symbol Names by appending" + " the MD5 hash of the module path">, + ResetBy<NegFlag>>; +defm unique_section_names : BoolFOption<"unique-section-names", + "CodeGenOpts.UniqueSectionNames", DefaultsToTrue, + ChangedBy<NegFlag, [], "Don't use unique names for text and data sections">, + ResetBy<PosFlag>>; -defm split_machine_functions: OptInFFlag<"split-machine-functions", - "Enable", "Disable", " late function splitting using profile information (x86 ELF)">; +defm split_machine_functions: BoolFOption<"split-machine-functions", + "CodeGenOpts.SplitMachineFunctions", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [], "Disable">, + BothFlags<[], " late function splitting using profile information (x86 ELF)">>; -defm strict_return : OptOutFFlag<"strict-return", "", - "Don't treat control flow paths that fall off the end of a non-void function as unreachable">; +defm strict_return : BoolFOption<"strict-return", + "CodeGenOpts.StrictReturn", DefaultsToTrue, + ChangedBy<NegFlag, [], "Don't treat control flow paths that fall off the end" + " of a non-void function as unreachable">, + ResetBy<PosFlag>>; def fenable_matrix : Flag<["-"], "fenable-matrix">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Enable matrix data type and related builtin functions">; + HelpText<"Enable matrix data type and related builtin functions">, + MarshallingInfoFlag<"LangOpts->MatrixTypes">; def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>, HelpText<"Place debug types in their own section (ELF Only)">; def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>; -defm debug_ranges_base_address : OptInFFlag<"debug-ranges-base-address", - "Use DWARF base address selection entries in .debug_ranges">; -def fsplit_dwarf_inlining: Flag <["-"], "fsplit-dwarf-inlining">, Group<f_Group>, - HelpText<"Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF">; -def fno_split_dwarf_inlining: Flag<["-"], "fno-split-dwarf-inlining">, Group<f_Group>, - Flags<[CC1Option]>; +defm debug_ranges_base_address : BoolFOption<"debug-ranges-base-address", + "CodeGenOpts.DebugRangesBaseAddress", DefaultsToFalse, + ChangedBy<PosFlag, [], "Use DWARF base address selection entries in .debug_ranges">, + ResetBy<NegFlag>>; +defm split_dwarf_inlining : BoolFOption<"split-dwarf-inlining", + "CodeGenOpts.SplitDwarfInlining", DefaultsToTrue, + ChangedBy<NegFlag>, + ResetBy<PosFlag, [], "Provide minimal debug info in the object/executable" + " to facilitate online symbolication/stack traces in the absence of" + " .dwo/.dwp files when using Split DWARF">>; def fdebug_default_version: Joined<["-"], "fdebug-default-version=">, Group<f_Group>, HelpText<"Default DWARF version to use, if a -g option caused DWARF debug info to be produced">; def fdebug_prefix_map_EQ @@ -2396,7 +2531,9 @@ def ffile_prefix_map_EQ def fmacro_prefix_map_EQ : Joined<["-"], "fmacro-prefix-map=">, Group<Preprocessor_Group>, Flags<[CC1Option]>, HelpText<"remap file source paths in predefined preprocessor macros">; -defm force_dwarf_frame : OptInFFlag<"force-dwarf-frame", "Always emit a debug frame section">; +defm force_dwarf_frame : BoolFOption<"force-dwarf-frame", + "CodeGenOpts.ForceDwarfFrameSection", DefaultsToFalse, + ChangedBy<PosFlag, [], "Always emit a debug frame section">, ResetBy<NegFlag>>; def g_Flag : Flag<["-"], "g">, Group<g_Group>, HelpText<"Generate source-level debug information">; def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>, @@ -2430,7 +2567,8 @@ def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group<g_Group>, def gcodeview : Flag<["-"], "gcodeview">, HelpText<"Generate CodeView debug information">, - Flags<[CC1Option, CC1AsOption, CoreOption]>; + Flags<[CC1Option, CC1AsOption, CoreOption]>, + MarshallingInfoFlag<"CodeGenOpts.EmitCodeView">; defm codeview_ghash : BoolOption<"codeview-ghash", "CodeGenOpts.CodeViewGHash", DefaultsToFalse, ChangedBy<PosFlag, [CC1Option], "Emit type record hashes in a .debug$H section">, @@ -2455,8 +2593,10 @@ def : Flag<["-"], "grecord-gcc-switches">, Alias<grecord_command_line>; def : Flag<["-"], "gno-record-gcc-switches">, Alias<gno_record_command_line>; def gstrict_dwarf : Flag<["-"], "gstrict-dwarf">, Group<g_flags_Group>; def gno_strict_dwarf : Flag<["-"], "gno-strict-dwarf">, Group<g_flags_Group>; -def gcolumn_info : Flag<["-"], "gcolumn-info">, Group<g_flags_Group>, Flags<[CoreOption]>; -def gno_column_info : Flag<["-"], "gno-column-info">, Group<g_flags_Group>, Flags<[CoreOption, CC1Option]>; +defm column_info : BoolCC1Option<"column-info", + "CodeGenOpts.DebugColumnInfo", DefaultsToTrue, + ChangedBy<NegFlag>, ResetBy<PosFlag>, BothFlags<[CoreOption]>, "g">, + Group<g_flags_Group>; def gsplit_dwarf : Flag<["-"], "gsplit-dwarf">, Group<g_flags_Group>; def gsplit_dwarf_EQ : Joined<["-"], "gsplit-dwarf=">, Group<g_flags_Group>, HelpText<"Set DWARF fission mode to either 'split' or 'single'">, @@ -2474,7 +2614,8 @@ def gz_EQ : Joined<["-"], "gz=">, Group<g_flags_Group>, HelpText<"DWARF debug sections compression type">; def gz : Flag<["-"], "gz">, Alias<gz_EQ>, AliasArgs<["zlib"]>, Group<g_flags_Group>; def gembed_source : Flag<["-"], "gembed-source">, Group<g_flags_Group>, Flags<[CC1Option]>, - HelpText<"Embed source text in DWARF debug sections">; + HelpText<"Embed source text in DWARF debug sections">, + MarshallingInfoFlag<"CodeGenOpts.EmbedSource">; def gno_embed_source : Flag<["-"], "gno-embed-source">, Group<g_flags_Group>, Flags<[NoXarchOption]>, HelpText<"Restore the default behavior of not embedding source text in DWARF debug sections">; @@ -2549,7 +2690,8 @@ def EB : Flag<["-"], "EB">, Alias<mbig_endian>; def m16 : Flag<["-"], "m16">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[NoXarchOption,CC1Option]>, - HelpText<"Enable hexagon-qdsp6 backward compatibility">; + HelpText<"Enable hexagon-qdsp6 backward compatibility">, + MarshallingInfoFlag<"LangOpts->HexagonQdsp6Compat">; def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>; @@ -2571,7 +2713,8 @@ def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group<clang_ignored_m_Grou def mlong_calls : Flag<["-"], "mlong-calls">, Group<m_Group>, HelpText<"Generate branches with extended addressability, usually via indirect jumps.">; def mdouble_EQ : Joined<["-"], "mdouble=">, Group<m_Group>, Values<"32,64">, Flags<[CC1Option]>, - HelpText<"Force double to be 32 bits or 64 bits">; + HelpText<"Force double to be 32 bits or 64 bits">, + MarshallingInfoStringInt<"LangOpts->DoubleSize", "0">; def LongDouble_Group : OptionGroup<"<LongDouble group>">, Group<m_Group>, DocName<"Long double flags">, DocBrief<[{Selects the long double implementation}]>; @@ -2604,7 +2747,8 @@ def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>, Flags<[CC1Option]>, MarshallingInfoString<"TargetOpts->CodeModel", [{"default"}]>; def mtls_size_EQ : Joined<["-"], "mtls-size=">, Group<m_Group>, Flags<[NoXarchOption, CC1Option]>, HelpText<"Specify bit size of immediate TLS offsets (AArch64 ELF only): " - "12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)">; + "12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)">, + MarshallingInfoStringInt<"CodeGenOpts.TLSSize">; def mimplicit_it_EQ : Joined<["-"], "mimplicit-it=">, Group<m_Group>; def mdefault_build_attributes : Joined<["-"], "mdefault-build-attributes">, Group<m_Group>; def mno_default_build_attributes : Joined<["-"], "mno-default-build-attributes">, Group<m_Group>; @@ -2623,7 +2767,8 @@ 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>; def malign_double : Flag<["-"], "malign-double">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Align doubles to two words in structs (x86 only)">; + HelpText<"Align doubles to two words in structs (x86 only)">, + MarshallingInfoFlag<"LangOpts->AlignDouble">; def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">; def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>; def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>; @@ -2647,7 +2792,8 @@ def mmacosx_version_min_EQ : Joined<["-"], "mmacosx-version-min=">, def mmacos_version_min_EQ : Joined<["-"], "mmacos-version-min=">, Group<m_Group>, Alias<mmacosx_version_min_EQ>; def mms_bitfields : Flag<["-"], "mms-bitfields">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">; + HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">, + MarshallingInfoFlag<"LangOpts->MSBitfields">; def moutline : Flag<["-"], "moutline">, Group<f_clang_Group>, Flags<[CC1Option]>, HelpText<"Enable function outlining (AArch64 only)">; def mno_outline : Flag<["-"], "mno-outline">, Group<f_clang_Group>, Flags<[CC1Option]>, @@ -2655,15 +2801,19 @@ def mno_outline : Flag<["-"], "mno-outline">, Group<f_clang_Group>, Flags<[CC1Op def mno_ms_bitfields : Flag<["-"], "mno-ms-bitfields">, Group<m_Group>, HelpText<"Do not set the default structure layout to be compatible with the Microsoft compiler standard">; def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Force realign the stack at entry to every function">; + HelpText<"Force realign the stack at entry to every function">, + MarshallingInfoFlag<"CodeGenOpts.StackRealignment">; def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Set the stack alignment">; + HelpText<"Set the stack alignment">, + MarshallingInfoStringInt<"CodeGenOpts.StackAlignment">; def mstack_probe_size : Joined<["-"], "mstack-probe-size=">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Set the stack probe size">; + HelpText<"Set the stack probe size">, + MarshallingInfoStringInt<"CodeGenOpts.StackProbeSize", "4096">; def mstack_arg_probe : Flag<["-"], "mstack-arg-probe">, Group<m_Group>, HelpText<"Enable stack probes">; def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Disable stack probes which are enabled by default">; + HelpText<"Disable stack probes which are enabled by default">, + MarshallingInfoFlag<"CodeGenOpts.NoStackArgProbe">; def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>, HelpText<"The thread model to use, e.g. posix, single (posix by default)">, Values<"posix,single">; def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>, @@ -2679,7 +2829,8 @@ def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">, Alias<fno_pascal_strings>; def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>; def mno_tls_direct_seg_refs : Flag<["-"], "mno-tls-direct-seg-refs">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Disable direct TLS access through segment registers">; + HelpText<"Disable direct TLS access through segment registers">, + MarshallingInfoFlag<"CodeGenOpts.IndirectTlsSegRefs">; def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>; def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>; def mno_soft_float : Flag<["-"], "mno-soft-float">, Group<m_Group>; @@ -2687,10 +2838,10 @@ def mno_stackrealign : Flag<["-"], "mno-stackrealign">, Group<m_Group>; def mretpoline : Flag<["-"], "mretpoline">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>; def mno_retpoline : Flag<["-"], "mno-retpoline">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>; -def mspeculative_load_hardening : Flag<["-"], "mspeculative-load-hardening">, - Group<m_Group>, Flags<[CoreOption,CC1Option]>; -def mno_speculative_load_hardening : Flag<["-"], "mno-speculative-load-hardening">, - Group<m_Group>, Flags<[CoreOption]>; +defm speculative_load_hardening : BoolOption<"speculative-load-hardening", + "CodeGenOpts.SpeculativeLoadHardening", DefaultsToFalse, + ChangedBy<PosFlag, [CC1Option]>, ResetBy<NegFlag>, BothFlags<[CoreOption]>, + "m">, Group<m_Group>; def mlvi_hardening : Flag<["-"], "mlvi-hardening">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>, HelpText<"Enable all mitigations for Load Value Injection (LVI)">; def mno_lvi_hardening : Flag<["-"], "mno-lvi-hardening">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>, @@ -2749,16 +2900,18 @@ def mno_neg_immediates: Flag<["-"], "mno-neg-immediates">, Group<m_arm_Features_ HelpText<"Disallow converting instructions with negative immediates to their negation or inversion.">; def mcmse : Flag<["-"], "mcmse">, Group<m_arm_Features_Group>, Flags<[NoXarchOption,CC1Option]>, - HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">; + HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">, + MarshallingInfoFlag<"LangOpts->Cmse">; def ForceAAPCSBitfieldLoad : Flag<["-"], "faapcs-bitfield-load">, Group<m_arm_Features_Group>, Flags<[NoXarchOption,CC1Option]>, - HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">; -def ForceNoAAPCSBitfieldWidth : Flag<["-"], "fno-aapcs-bitfield-width">, Group<m_arm_Features_Group>, - Flags<[NoXarchOption,CC1Option]>, - HelpText<"Do not follow the AAPCS standard requirement that volatile bit-field width is dictated by the field container type. (ARM only).">; -def AAPCSBitfieldWidth : Flag<["-"], "faapcs-bitfield-width">, Group<m_arm_Features_Group>, - Flags<[NoXarchOption,CC1Option]>, - HelpText<"Follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).">; + HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">, + MarshallingInfoFlag<"CodeGenOpts.ForceAAPCSBitfieldLoad">; +defm aapcs_bitfield_width : BoolOption<"aapcs-bitfield-width", + "CodeGenOpts.AAPCSBitfieldWidth", DefaultsToTrue, + ChangedBy<NegFlag, [], "Do not follow">, ResetBy<PosFlag, [], "Follow">, + BothFlags<[NoXarchOption, CC1Option], " the AAPCS standard requirement stating that" + " volatile bit-field width is dictated by the field container type. (ARM only).">, + "f">, Group<m_arm_Features_Group>; def mgeneral_regs_only : Flag<["-"], "mgeneral-regs-only">, Group<m_aarch64_Features_Group>, HelpText<"Generate code which only uses the general purpose registers (AArch64 only)">; @@ -2922,16 +3075,20 @@ def msvr4_struct_return : Flag<["-"], "msvr4-struct-return">, def mvx : Flag<["-"], "mvx">, Group<m_Group>; def mno_vx : Flag<["-"], "mno-vx">, Group<m_Group>; -defm zvector : OptInFFlag<"zvector", "Enable System z vector language extension">; +defm zvector : BoolFOption<"zvector", + "LangOpts->ZVector", DefaultsToFalse, + ChangedBy<PosFlag, [], "Enable System z vector language extension">, + ResetBy<NegFlag>>; def mzvector : Flag<["-"], "mzvector">, Alias<fzvector>; def mno_zvector : Flag<["-"], "mno-zvector">, Alias<fno_zvector>; def mignore_xcoff_visibility : Flag<["-"], "mignore-xcoff-visibility">, Group<m_Group>, HelpText<"Not emit the visibility attribute for asm in AIX OS or give all symbols 'unspecified' visibility in XCOFF object file">, Flags<[CC1Option]>; -def mbackchain : Flag<["-"], "mbackchain">, Group<m_Group>, Flags<[NoXarchOption,CC1Option]>, - HelpText<"Link stack frames through backchain on System Z">; -def mno_backchain : Flag<["-"], "mno-backchain">, Group<m_Group>, Flags<[NoXarchOption,CC1Option]>; +defm backchain : BoolOption<"backchain", + "CodeGenOpts.Backchain", DefaultsToFalse, + ChangedBy<PosFlag, [], "Link stack frames through backchain on System Z">, + ResetBy<NegFlag>, BothFlags<[NoXarchOption,CC1Option]>, "m">, Group<m_Group>; def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>; def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>; @@ -2944,10 +3101,12 @@ def mtls_direct_seg_refs : Flag<["-"], "mtls-direct-seg-refs">, Group<m_Group>, HelpText<"Enable direct TLS access through segment registers (default)">; def mregparm_EQ : Joined<["-"], "mregparm=">, Group<m_Group>; def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>, - HelpText<"(integrated-as) Relax all machine instructions">; + HelpText<"(integrated-as) Relax all machine instructions">, + MarshallingInfoFlag<"CodeGenOpts.RelaxAll">; def mincremental_linker_compatible : Flag<["-"], "mincremental-linker-compatible">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>, - HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">; + HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">, + MarshallingInfoFlag<"CodeGenOpts.IncrementalLinkerCompatible">; def mno_incremental_linker_compatible : Flag<["-"], "mno-incremental-linker-compatible">, Group<m_Group>, HelpText<"(integrated-as) Emit an object file which cannot be used with an incremental linker">; def mrtd : Flag<["-"], "mrtd">, Group<m_Group>, Flags<[CC1Option]>, @@ -2955,7 +3114,8 @@ def mrtd : Flag<["-"], "mrtd">, Group<m_Group>, Flags<[CC1Option]>, def msmall_data_threshold_EQ : Joined <["-"], "msmall-data-threshold=">, Group<m_Group>, Alias<G>; def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Use software floating point">; + HelpText<"Use software floating point">, + MarshallingInfoFlag<"CodeGenOpts.SoftFloat">; def moutline_atomics : Flag<["-"], "moutline-atomics">, Group<f_clang_Group>, Flags<[CC1Option]>, HelpText<"Generate local calls to out-of-line atomic operations">; def mno_outline_atomics : Flag<["-"], "mno-outline-atomics">, Group<f_clang_Group>, Flags<[CC1Option]>, @@ -2966,25 +3126,30 @@ def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>; def mrecip : Flag<["-"], "mrecip">, Group<m_Group>; def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>; def mprefer_vector_width_EQ : Joined<["-"], "mprefer-vector-width=">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">; + HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">, + MarshallingInfoString<"CodeGenOpts.PreferVectorWidth">; def mstack_protector_guard_EQ : Joined<["-"], "mstack-protector-guard=">, Group<m_Group>, Flags<[CC1Option]>, HelpText<"Use the given guard (global, tls) for addressing the stack-protector guard">; def mstack_protector_guard_offset_EQ : Joined<["-"], "mstack-protector-guard-offset=">, Group<m_Group>, Flags<[CC1Option]>, HelpText<"Use the given offset for addressing the stack-protector guard">; def mstack_protector_guard_reg_EQ : Joined<["-"], "mstack-protector-guard-reg=">, Group<m_Group>, Flags<[CC1Option]>, HelpText<"Use the given reg for addressing the stack-protector guard">; -def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_Group>, - Flags<[CC1Option]>, - HelpText<"Use copy relocations support for PIE builds">; -def mno_pie_copy_relocations : Flag<["-"], "mno-pie-copy-relocations">, Group<m_Group>; +defm pie_copy_relocations : BoolOption<"pie-copy-relocations", + "CodeGenOpts.PIECopyRelocations", DefaultsToFalse, + ChangedBy<PosFlag, [CC1Option], "Use copy relocations support for PIE builds">, + ResetBy<NegFlag>, BothFlags<[]>, "m">, Group<m_Group>; def mfentry : Flag<["-"], "mfentry">, HelpText<"Insert calls to fentry at function entry (x86/SystemZ only)">, - Flags<[CC1Option]>, Group<m_Group>; + Flags<[CC1Option]>, Group<m_Group>, + MarshallingInfoFlag<"CodeGenOpts.CallFEntry">; def mnop_mcount : Flag<["-"], "mnop-mcount">, HelpText<"Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.">, - Flags<[CC1Option]>, Group<m_Group>; + Flags<[CC1Option]>, Group<m_Group>, + MarshallingInfoFlag<"CodeGenOpts.MNopMCount">; def mrecord_mcount : Flag<["-"], "mrecord-mcount">, HelpText<"Generate a __mcount_loc section entry for each __fentry__ call.">, - Flags<[CC1Option]>, Group<m_Group>; + Flags<[CC1Option]>, Group<m_Group>, + MarshallingInfoFlag<"CodeGenOpts.RecordMCount">; def mpacked_stack : Flag<["-"], "mpacked-stack">, HelpText<"Use packed stack layout (SystemZ only).">, - Flags<[CC1Option]>, Group<m_Group>; + Flags<[CC1Option]>, Group<m_Group>, + MarshallingInfoFlag<"CodeGenOpts.PackedStack">; def mno_packed_stack : Flag<["-"], "mno-packed-stack">, Flags<[CC1Option]>, Group<m_Group>; def mips16 : Flag<["-"], "mips16">, Group<m_mips_Features_Group>; def mno_mips16 : Flag<["-"], "mno-mips16">, Group<m_mips_Features_Group>; @@ -3150,7 +3315,7 @@ def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>; def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">; def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>, HelpText<"Disable builtin #include directories">, - MarshallingInfoFlag<"HeaderSearchOpts->UseBuiltinIncludes", "true">, IsNegative; + MarshallingInfoNegativeFlag<"HeaderSearchOpts->UseBuiltinIncludes">; def nogpuinc : Flag<["-"], "nogpuinc">, HelpText<"Do not add include paths for CUDA/HIP and" " do not include the default CUDA/HIP wrapper headers">; def : Flag<["-"], "nocudainc">, Alias<nogpuinc>; @@ -3171,7 +3336,7 @@ def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>; def nostdlibinc : Flag<["-"], "nostdlibinc">; def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>, HelpText<"Disable standard #include directories for the C++ standard library">, - MarshallingInfoFlag<"HeaderSearchOpts->UseStandardCXXIncludes", "true">, IsNegative; + MarshallingInfoNegativeFlag<"HeaderSearchOpts->UseStandardCXXIncludes">; def nostdlib : Flag<["-"], "nostdlib">, Group<Link_Group>; def nostdlibxx : Flag<["-"], "nostdlib++">; def object : Flag<["-"], "object">; @@ -3183,7 +3348,8 @@ def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">; def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>; def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>; def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>; -def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>; +def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>, + MarshallingInfoFlag<"CodeGenOpts.InstrumentForProfiling">; def pipe : Flag<["-", "--"], "pipe">, HelpText<"Use pipes between commands, when possible">; def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">; @@ -3192,7 +3358,8 @@ def preload : Flag<["-"], "preload">; def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">, HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">; def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>, - HelpText<"Enable Objective-C Ivar layout bitmap print trace">; + HelpText<"Enable Objective-C Ivar layout bitmap print trace">, + MarshallingInfoFlag<"LangOpts->ObjCGCBitmapPrint">; def print_libgcc_file_name : Flag<["-", "--"], "print-libgcc-file-name">, HelpText<"Print the library path for the currently used compiler runtime " "library (\"libgcc.a\" or \"libclang_rt.builtins.*.a\")">; @@ -3214,9 +3381,10 @@ def print_targets : Flag<["-", "--"], "print-targets">, HelpText<"Print the registered targets">; def private__bundle : Flag<["-"], "private_bundle">; def pthreads : Flag<["-"], "pthreads">; -def pthread : Flag<["-"], "pthread">, Flags<[CC1Option]>, - HelpText<"Support POSIX threads in generated code">; -def no_pthread : Flag<["-"], "no-pthread">, Flags<[CC1Option]>; +defm pthread : BoolOption<"pthread", + "LangOpts->POSIXThreads", DefaultsToFalse, + ChangedBy<PosFlag, [], "Support POSIX threads in generated code">, + ResetBy<NegFlag>, BothFlags<[CC1Option]>>; def p : Flag<["-"], "p">; def pie : Flag<["-"], "pie">, Group<Link_Group>; def static_pie : Flag<["-"], "static-pie">, Group<Link_Group>; @@ -3321,7 +3489,8 @@ def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[NoXarchOption]>, def time : Flag<["-"], "time">, HelpText<"Time individual commands">; def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, Flags<[CC1Option]>, - HelpText<"Enable some traditional CPP emulation">; + HelpText<"Enable some traditional CPP emulation">, + MarshallingInfoFlag<"LangOpts->TraditionalCPP">; def traditional : Flag<["-", "--"], "traditional">; def trigraphs : Flag<["-", "--"], "trigraphs">, Alias<ftrigraphs>, HelpText<"Process trigraph sequences">; @@ -3332,7 +3501,7 @@ def umbrella : Separate<["-"], "umbrella">; def undefined : JoinedOrSeparate<["-"], "undefined">, Group<u_Group>; def undef : Flag<["-"], "undef">, Group<u_Group>, Flags<[CC1Option]>, HelpText<"undef all system defines">, - MarshallingInfoFlag<"PreprocessorOpts->UsePredefines", "true">, IsNegative; + MarshallingInfoNegativeFlag<"PreprocessorOpts->UsePredefines">; def unexported__symbols__list : Separate<["-"], "unexported_symbols_list">; def u : JoinedOrSeparate<["-"], "u">, Group<u_Group>; def v : Flag<["-"], "v">, Flags<[CC1Option, CoreOption]>, @@ -3352,7 +3521,10 @@ def x : JoinedOrSeparate<["-"], "x">, Flags<[NoXarchOption,CC1Option]>, MetaVarName<"<language>">; def y : Joined<["-"], "y">; -defm integrated_as : OptOutFFlag<"integrated-as", "Enable the integrated assembler", "Disable the integrated assembler">; +defm integrated_as : BoolFOption<"integrated-as", + "CodeGenOpts.DisableIntegratedAS", DefaultsToFalse, + ChangedBy<NegFlag, [], "Disable">, ResetBy<PosFlag, [], "Enable">, + BothFlags<[], " the integrated assembler">>; def fintegrated_cc1 : Flag<["-"], "fintegrated-cc1">, Flags<[CoreOption, NoXarchOption]>, Group<f_Group>, @@ -3792,8 +3964,9 @@ defm inline_small_functions : BooleanFFlag<"inline-small-functions">, defm ipa_cp : BooleanFFlag<"ipa-cp">, Group<clang_ignored_gcc_optimization_f_Group>; defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>; -def fsemantic_interposition : Flag<["-"], "fsemantic-interposition">, Group<f_Group>, Flags<[CC1Option]>; -def fno_semantic_interposition: Flag<["-"], "fno-semantic-interposition">, Group<f_Group>; +defm semantic_interposition : BoolFOption<"semantic-interposition", + "LangOpts->SemanticInterposition", DefaultsToFalse, + ChangedBy<PosFlag>, ResetBy<NegFlag>>; defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>; defm peel_loops : BooleanFFlag<"peel-loops">, Group<clang_ignored_gcc_optimization_f_Group>; defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>; @@ -3912,10 +4085,11 @@ defm underscoring : BooleanFFlag<"underscoring">, Group<gfortran_Group>; defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>; // C++ SYCL options -def fsycl : Flag<["-"], "fsycl">, Group<sycl_Group>, Flags<[CC1Option, CoreOption]>, - HelpText<"Enable SYCL kernels compilation for device">; -def fno_sycl : Flag<["-"], "fno-sycl">, Group<sycl_Group>, Flags<[CoreOption]>, - HelpText<"Disable SYCL kernels compilation for device">; +defm sycl : BoolOption<"sycl", + "LangOpts->SYCL", DefaultsToFalse, + ChangedBy<PosFlag, [CC1Option], "Enable">, ResetBy<NegFlag, [], "Disable">, + BothFlags<[CoreOption], " SYCL kernels compilation for device">, "f">, + Group<sycl_Group>; def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>, HelpText<"SYCL language standard to compile for.">, Values<"2017, 121, 1.2.1, sycl-1.2.1">; @@ -4137,33 +4311,50 @@ def migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">, //===----------------------------------------------------------------------===// let Flags = [CC1Option, CC1AsOption, NoDriverOption] in { -def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">; +def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">, + Values<"line-tables-only,line-directives-only,constructor,limited,standalone,unused-types">, + NormalizedValuesScope<"codegenoptions">, + NormalizedValues<["DebugLineTablesOnly", "DebugDirectivesOnly", "DebugInfoConstructor", + "LimitedDebugInfo", "FullDebugInfo", "UnusedTypeInfo"]>, + MarshallingInfoString<"CodeGenOpts.DebugInfo", "NoDebugInfo">, AutoNormalizeEnum; def debug_info_macro : Flag<["-"], "debug-info-macro">, - HelpText<"Emit macro debug information">; + HelpText<"Emit macro debug information">, + MarshallingInfoFlag<"CodeGenOpts.MacroDebugInfo">; def default_function_attr : Separate<["-"], "default-function-attr">, HelpText<"Apply given attribute to all functions">; -def dwarf_version_EQ : Joined<["-"], "dwarf-version=">; -def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">; +def dwarf_version_EQ : Joined<["-"], "dwarf-version=">, + MarshallingInfoStringInt<"CodeGenOpts.DwarfVersion">; +def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">, + Values<"gdb,lldb,sce">, + NormalizedValuesScope<"llvm::DebuggerKind">, NormalizedValues<["GDB", "LLDB", "SCE"]>, + MarshallingInfoString<"CodeGenOpts.DebuggerTuning", "Default">, AutoNormalizeEnum; def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">, - HelpText<"The string to embed in the Dwarf debug flags record.">; + HelpText<"The string to embed in the Dwarf debug flags record.">, + MarshallingInfoString<"CodeGenOpts.DwarfDebugFlags">; def record_command_line : Separate<["-"], "record-command-line">, - HelpText<"The string to embed in the .LLVM.command.line section.">; + HelpText<"The string to embed in the .LLVM.command.line section.">, + MarshallingInfoString<"CodeGenOpts.RecordCommandLine">; def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">, HelpText<"DWARF debug sections compression type">; def compress_debug_sections : Flag<["-", "--"], "compress-debug-sections">, Alias<compress_debug_sections_EQ>, AliasArgs<["zlib"]>; def mno_exec_stack : Flag<["-"], "mnoexecstack">, - HelpText<"Mark the file as not needing an executable stack">; + HelpText<"Mark the file as not needing an executable stack">, + MarshallingInfoFlag<"CodeGenOpts.NoExecStack">; def massembler_no_warn : Flag<["-"], "massembler-no-warn">, - HelpText<"Make assembler not emit warnings">; + HelpText<"Make assembler not emit warnings">, + MarshallingInfoFlag<"CodeGenOpts.NoWarn">; def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">, - HelpText<"Make assembler warnings fatal">; + HelpText<"Make assembler warnings fatal">, + MarshallingInfoFlag<"CodeGenOpts.FatalWarnings">; def mrelax_relocations : Flag<["--"], "mrelax-relocations">, - HelpText<"Use relaxable elf relocations">; + HelpText<"Use relaxable elf relocations">, + MarshallingInfoFlag<"CodeGenOpts.RelaxELFRelocations">; def msave_temp_labels : Flag<["-"], "msave-temp-labels">, HelpText<"Save temporary labels in the symbol table. " "Note this may change .s semantics and shouldn't generally be used " - "on compiler-generated code.">; + "on compiler-generated code.">, + MarshallingInfoFlag<"CodeGenOpts.SaveTempLabels">; def mrelocation_model : Separate<["-"], "mrelocation-model">, HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">, NormalizedValuesScope<"llvm::Reloc">, @@ -4171,42 +4362,55 @@ def mrelocation_model : Separate<["-"], "mrelocation-model">, MarshallingInfoString<"CodeGenOpts.RelocationModel", "PIC_">, AutoNormalizeEnum; def fno_math_builtin : Flag<["-"], "fno-math-builtin">, - HelpText<"Disable implicit builtin knowledge of math functions">; + HelpText<"Disable implicit builtin knowledge of math functions">, + MarshallingInfoFlag<"LangOpts->NoMathBuiltin">; def fuse_ctor_homing: Flag<["-"], "fuse-ctor-homing">, HelpText<"Use constructor homing if we are using limited debug info already">; } def disable_llvm_verifier : Flag<["-"], "disable-llvm-verifier">, - HelpText<"Don't run the LLVM IR verifier pass">; + HelpText<"Don't run the LLVM IR verifier pass">, + MarshallingInfoNegativeFlag<"CodeGenOpts.VerifyModule">; def disable_llvm_passes : Flag<["-"], "disable-llvm-passes">, HelpText<"Use together with -emit-llvm to get pristine LLVM IR from the " - "frontend by not running any LLVM passes at all">; + "frontend by not running any LLVM passes at all">, + MarshallingInfoFlag<"CodeGenOpts.DisableLLVMPasses">; def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">, Alias<disable_llvm_passes>; def disable_lifetimemarkers : Flag<["-"], "disable-lifetime-markers">, HelpText<"Disable lifetime-markers emission even when optimizations are " - "enabled">; + "enabled">, + MarshallingInfoFlag<"CodeGenOpts.DisableLifetimeMarkers">; def disable_O0_optnone : Flag<["-"], "disable-O0-optnone">, - HelpText<"Disable adding the optnone attribute to functions at O0">; + HelpText<"Disable adding the optnone attribute to functions at O0">, + MarshallingInfoFlag<"CodeGenOpts.DisableO0ImplyOptNone">; def disable_red_zone : Flag<["-"], "disable-red-zone">, - HelpText<"Do not emit code that uses the red zone.">; + HelpText<"Do not emit code that uses the red zone.">, + MarshallingInfoFlag<"CodeGenOpts.DisableRedZone">; def dwarf_ext_refs : Flag<["-"], "dwarf-ext-refs">, HelpText<"Generate debug info with external references to clang modules" - " or precompiled headers">; + " or precompiled headers">, + MarshallingInfoFlag<"CodeGenOpts.DebugTypeExtRefs">; def dwarf_explicit_import : Flag<["-"], "dwarf-explicit-import">, HelpText<"Generate explicit import from anonymous namespace to containing" - " scope">; + " scope">, + MarshallingInfoFlag<"CodeGenOpts.DebugExplicitImport">; def debug_forward_template_params : Flag<["-"], "debug-forward-template-params">, HelpText<"Emit complete descriptions of template parameters in forward" - " declarations">; + " declarations">, + MarshallingInfoFlag<"CodeGenOpts.DebugFwdTemplateParams">; def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">, - HelpText<"Emit an error if a C++ static local initializer would need a guard variable">; + HelpText<"Emit an error if a C++ static local initializer would need a guard variable">, + MarshallingInfoFlag<"CodeGenOpts.ForbidGuardVariables">; def no_implicit_float : Flag<["-"], "no-implicit-float">, - HelpText<"Don't generate implicit floating point instructions">; + HelpText<"Don't generate implicit floating point instructions">, + MarshallingInfoFlag<"CodeGenOpts.NoImplicitFloat">; def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">, - HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">; + HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">, + MarshallingInfoFlag<"LangOpts->DumpVTableLayouts">; def fmerge_functions : Flag<["-"], "fmerge-functions">, - HelpText<"Permit merging of identical functions when optimizing.">; + HelpText<"Permit merging of identical functions when optimizing.">, + MarshallingInfoFlag<"CodeGenOpts.MergeFunctions">; def coverage_data_file : Separate<["-"], "coverage-data-file">, HelpText<"Emit coverage data to this filename.">; def coverage_data_file_EQ : Joined<["-"], "coverage-data-file=">, @@ -4218,21 +4422,29 @@ def coverage_notes_file_EQ : Joined<["-"], "coverage-notes-file=">, def coverage_version_EQ : Joined<["-"], "coverage-version=">, HelpText<"Four-byte version string for gcov files.">; def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">, - HelpText<"Dump the coverage mapping records, for testing">; + HelpText<"Dump the coverage mapping records, for testing">, + MarshallingInfoFlag<"CodeGenOpts.DumpCoverageMapping">; def fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfield-access">, - HelpText<"Use register sized accesses to bit-fields, when possible.">; + HelpText<"Use register sized accesses to bit-fields, when possible.">, + MarshallingInfoFlag<"CodeGenOpts.UseRegisterSizedBitfieldAccess">; def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">, - HelpText<"Turn off Type Based Alias Analysis">; + HelpText<"Turn off Type Based Alias Analysis">, + MarshallingInfoFlag<"CodeGenOpts.RelaxedAliasing">; def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">, - HelpText<"Turn off struct-path aware Type Based Alias Analysis">; + HelpText<"Turn off struct-path aware Type Based Alias Analysis">, + MarshallingInfoNegativeFlag<"CodeGenOpts.StructPathTBAA">; def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">, HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">; def mdebug_pass : Separate<["-"], "mdebug-pass">, - HelpText<"Enable additional debug output">; + HelpText<"Enable additional debug output">, + MarshallingInfoString<"CodeGenOpts.DebugPass">; def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">, - HelpText<"Specify which frame pointers to retain (all, non-leaf, none).">, Values<"all,non-leaf,none">; + HelpText<"Specify which frame pointers to retain (all, non-leaf, none).">, Values<"all,non-leaf,none">, + NormalizedValuesScope<"CodeGenOptions::FramePointerKind">, NormalizedValues<["All", "NonLeaf", "None"]>, + MarshallingInfoString<"CodeGenOpts.FramePointer", "None">, AutoNormalizeEnum; def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">, - HelpText<"Disable tail call optimization, keeping the call stack accurate">; + HelpText<"Disable tail call optimization, keeping the call stack accurate">, + MarshallingInfoFlag<"CodeGenOpts.DisableTailCalls">; def menable_no_infinities : Flag<["-"], "menable-no-infs">, HelpText<"Allow optimization to assume there are no infinities.">, MarshallingInfoFlag<"LangOpts->NoHonorInfs">, ImpliedByAnyOf<[ffinite_math_only]>; @@ -4243,23 +4455,31 @@ def mreassociate : Flag<["-"], "mreassociate">, HelpText<"Allow reassociation transformations for floating-point instructions">, MarshallingInfoFlag<"LangOpts->AllowFPReassoc">, ImpliedByAnyOf<[menable_unsafe_fp_math]>; def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">, - HelpText<"Use IEEE 754 quadruple-precision for long double">; + HelpText<"Use IEEE 754 quadruple-precision for long double">, + MarshallingInfoFlag<"LangOpts->PPCIEEELongDouble">; def mfloat_abi : Separate<["-"], "mfloat-abi">, - HelpText<"The float ABI to use">; + HelpText<"The float ABI to use">, + MarshallingInfoString<"CodeGenOpts.FloatABI">; def mtp : Separate<["-"], "mtp">, HelpText<"Mode for reading thread pointer">; def mlimit_float_precision : Separate<["-"], "mlimit-float-precision">, - HelpText<"Limit float precision to the given value">; + HelpText<"Limit float precision to the given value">, + MarshallingInfoString<"CodeGenOpts.LimitFloatPrecision">; def split_stacks : Flag<["-"], "split-stacks">, - HelpText<"Try to use a split stack if possible.">; + HelpText<"Try to use a split stack if possible.">, + MarshallingInfoFlag<"CodeGenOpts.EnableSegmentedStacks">; def mregparm : Separate<["-"], "mregparm">, - HelpText<"Limit the number of registers available for integer arguments">; + HelpText<"Limit the number of registers available for integer arguments">, + MarshallingInfoStringInt<"CodeGenOpts.NumRegisterParameters">; def msmall_data_limit : Separate<["-"], "msmall-data-limit">, - HelpText<"Put global and static data smaller than the limit into a special section">; + HelpText<"Put global and static data smaller than the limit into a special section">, + MarshallingInfoStringInt<"CodeGenOpts.SmallDataLimit">; def munwind_tables : Flag<["-"], "munwind-tables">, - HelpText<"Generate unwinding tables for all functions">; + HelpText<"Generate unwinding tables for all functions">, + MarshallingInfoFlag<"CodeGenOpts.UnwindTables">; def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">, - HelpText<"Emit complete constructors and destructors as aliases when possible">; + HelpText<"Emit complete constructors and destructors as aliases when possible">, + MarshallingInfoFlag<"CodeGenOpts.CXXCtorDtorAliases">; def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">, HelpText<"Link the given bitcode file before performing optimizations.">; def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">, @@ -4268,72 +4488,96 @@ def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">, def mlink_cuda_bitcode : Separate<["-"], "mlink-cuda-bitcode">, Alias<mlink_builtin_bitcode>; def vectorize_loops : Flag<["-"], "vectorize-loops">, - HelpText<"Run the Loop vectorization passes">; + HelpText<"Run the Loop vectorization passes">, + MarshallingInfoFlag<"CodeGenOpts.VectorizeLoop">; def vectorize_slp : Flag<["-"], "vectorize-slp">, - HelpText<"Run the SLP vectorization passes">; + HelpText<"Run the SLP vectorization passes">, + MarshallingInfoFlag<"CodeGenOpts.VectorizeSLP">; def dependent_lib : Joined<["--"], "dependent-lib=">, HelpText<"Add dependent library">; def linker_option : Joined<["--"], "linker-option=">, HelpText<"Add linker option">; def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">, - HelpText<"Sanitizer coverage type">; + HelpText<"Sanitizer coverage type">, + MarshallingInfoStringInt<"CodeGenOpts.SanitizeCoverageType">; def fsanitize_coverage_indirect_calls : Flag<["-"], "fsanitize-coverage-indirect-calls">, - HelpText<"Enable sanitizer coverage for indirect calls">; + HelpText<"Enable sanitizer coverage for indirect calls">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageIndirectCalls">; def fsanitize_coverage_trace_bb : Flag<["-"], "fsanitize-coverage-trace-bb">, - HelpText<"Enable basic block tracing in sanitizer coverage">; + HelpText<"Enable basic block tracing in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceBB">; def fsanitize_coverage_trace_cmp : Flag<["-"], "fsanitize-coverage-trace-cmp">, - HelpText<"Enable cmp instruction tracing in sanitizer coverage">; + HelpText<"Enable cmp instruction tracing in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceCmp">; def fsanitize_coverage_trace_div : Flag<["-"], "fsanitize-coverage-trace-div">, - HelpText<"Enable div instruction tracing in sanitizer coverage">; + HelpText<"Enable div instruction tracing in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceDiv">; def fsanitize_coverage_trace_gep : Flag<["-"], "fsanitize-coverage-trace-gep">, - HelpText<"Enable gep instruction tracing in sanitizer coverage">; + HelpText<"Enable gep instruction tracing in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceGep">; def fsanitize_coverage_8bit_counters : Flag<["-"], "fsanitize-coverage-8bit-counters">, - HelpText<"Enable frequency counters in sanitizer coverage">; + HelpText<"Enable frequency counters in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverage8bitCounters">; def fsanitize_coverage_inline_8bit_counters : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">, - HelpText<"Enable inline 8-bit counters in sanitizer coverage">; + HelpText<"Enable inline 8-bit counters in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInline8bitCounters">; def fsanitize_coverage_inline_bool_flag : Flag<["-"], "fsanitize-coverage-inline-bool-flag">, - HelpText<"Enable inline bool flag in sanitizer coverage">; + HelpText<"Enable inline bool flag in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInlineBoolFlag">; def fsanitize_coverage_pc_table : Flag<["-"], "fsanitize-coverage-pc-table">, - HelpText<"Create a table of coverage-instrumented PCs">; + HelpText<"Create a table of coverage-instrumented PCs">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoveragePCTable">; def fsanitize_coverage_trace_pc : Flag<["-"], "fsanitize-coverage-trace-pc">, - HelpText<"Enable PC tracing in sanitizer coverage">; + HelpText<"Enable PC tracing in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePC">; def fsanitize_coverage_trace_pc_guard : Flag<["-"], "fsanitize-coverage-trace-pc-guard">, - HelpText<"Enable PC tracing with guard in sanitizer coverage">; + HelpText<"Enable PC tracing with guard in sanitizer coverage">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePCGuard">; def fsanitize_coverage_no_prune : Flag<["-"], "fsanitize-coverage-no-prune">, - HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">; + HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageNoPrune">; def fsanitize_coverage_stack_depth : Flag<["-"], "fsanitize-coverage-stack-depth">, - HelpText<"Enable max stack depth tracing">; + HelpText<"Enable max stack depth tracing">, + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageStackDepth">; def fpatchable_function_entry_offset_EQ : Joined<["-"], "fpatchable-function-entry-offset=">, MetaVarName<"<M>">, - HelpText<"Generate M NOPs before function entry">; + HelpText<"Generate M NOPs before function entry">, + MarshallingInfoStringInt<"CodeGenOpts.PatchableFunctionEntryOffset">; def fprofile_instrument_EQ : Joined<["-"], "fprofile-instrument=">, HelpText<"Enable PGO instrumentation. The accepted value is clang, llvm, " - "or none">, Values<"none,clang,llvm">; + "or none">, Values<"none,clang,llvm,csllvm">, + NormalizedValuesScope<"CodeGenOptions">, + NormalizedValues<["ProfileNone", "ProfileClangInstr", "ProfileIRInstr", "ProfileCSIRInstr"]>, + MarshallingInfoString<"CodeGenOpts.ProfileInstr", "ProfileNone">, AutoNormalizeEnum; def fprofile_instrument_path_EQ : Joined<["-"], "fprofile-instrument-path=">, HelpText<"Generate instrumented code to collect execution counts into " - "<file> (overridden by LLVM_PROFILE_FILE env var)">; + "<file> (overridden by LLVM_PROFILE_FILE env var)">, + MarshallingInfoString<"CodeGenOpts.InstrProfileOutput">; def fprofile_instrument_use_path_EQ : Joined<["-"], "fprofile-instrument-use-path=">, - HelpText<"Specify the profile path in PGO use compilation">; + HelpText<"Specify the profile path in PGO use compilation">, + MarshallingInfoString<"CodeGenOpts.ProfileInstrumentUsePath">; def flto_visibility_public_std: Flag<["-"], "flto-visibility-public-std">, - HelpText<"Use public LTO visibility for classes in std and stdext namespaces">; -def flto_unit: Flag<["-"], "flto-unit">, - HelpText<"Emit IR to support LTO unit features (CFI, whole program vtable opt)">; -def fno_lto_unit: Flag<["-"], "fno-lto-unit">; + HelpText<"Use public LTO visibility for classes in std and stdext namespaces">, + MarshallingInfoFlag<"CodeGenOpts.LTOVisibilityPublicStd">; +defm lto_unit : BoolCC1Option<"lto-unit", + "CodeGenOpts.LTOUnit", DefaultsToFalse, + ChangedBy<PosFlag, [], "Emit IR to support LTO unit features (CFI, whole program vtable opt)">, + ResetBy<NegFlag>, BothFlags<[]>, "f">; defm debug_pass_manager : BoolOption<"debug-pass-manager", "CodeGenOpts.DebugPassManager", DefaultsToFalse, ChangedBy<PosFlag, [], "Prints debug information for the new pass manager">, @@ -4341,18 +4585,23 @@ defm debug_pass_manager : BoolOption<"debug-pass-manager", BothFlags<[]>, "f">; def fexperimental_debug_variable_locations : Flag<["-"], "fexperimental-debug-variable-locations">, - HelpText<"Use experimental new value-tracking variable locations">; + HelpText<"Use experimental new value-tracking variable locations">, + MarshallingInfoFlag<"CodeGenOpts.ValueTrackingVariableLocations">; // The driver option takes the key as a parameter to the -msign-return-address= // and -mbranch-protection= options, but CC1 has a separate option so we // don't have to parse the parameter twice. def msign_return_address_key_EQ : Joined<["-"], "msign-return-address-key=">, Values<"a_key,b_key">; -def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">; -def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">; +def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">, + MarshallingInfoFlag<"LangOpts->BranchTargetEnforcement">; +def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">, + MarshallingInfoNegativeFlag<"LangOpts->DllExportInlines">; def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">, - HelpText<"Emit Windows Control Flow Guard tables only (no checks)">; + HelpText<"Emit Windows Control Flow Guard tables only (no checks)">, + MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuardNoChecks">; def cfguard : Flag<["-"], "cfguard">, - HelpText<"Emit Windows Control Flow Guard tables and checks">; + HelpText<"Emit Windows Control Flow Guard tables and checks">, + MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuard">; def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">, Group<f_Group>; @@ -4452,10 +4701,10 @@ def code_completion_patterns : Flag<["-"], "code-completion-patterns">, MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeCodePatterns">; def no_code_completion_globals : Flag<["-"], "no-code-completion-globals">, HelpText<"Do not include global declarations in code-completion results.">, - MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeGlobals", "true">, IsNegative; + MarshallingInfoNegativeFlag<"FrontendOpts.CodeCompleteOpts.IncludeGlobals">; def no_code_completion_ns_level_decls : Flag<["-"], "no-code-completion-ns-level-decls">, HelpText<"Do not include declarations inside namespaces (incl. global namespace) in the code-completion results.">, - MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeNamespaceLevelDecls", "true">, IsNegative; + MarshallingInfoNegativeFlag<"FrontendOpts.CodeCompleteOpts.IncludeNamespaceLevelDecls">; def code_completion_brief_comments : Flag<["-"], "code-completion-brief-comments">, HelpText<"Include brief documentation comments in code-completion results.">, MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeBriefComments">; @@ -4466,7 +4715,8 @@ def disable_free : Flag<["-"], "disable-free">, HelpText<"Disable freeing of memory on exit">, MarshallingInfoFlag<"FrontendOpts.DisableFree">; def discard_value_names : Flag<["-"], "discard-value-names">, - HelpText<"Discard value names in LLVM IR">; + HelpText<"Discard value names in LLVM IR">, + MarshallingInfoFlag<"CodeGenOpts.DiscardValueNames">; def load : Separate<["-"], "load">, MetaVarName<"<dsopath>">, HelpText<"Load the named plugin (dynamic shared object)">; def plugin : Separate<["-"], "plugin">, MetaVarName<"<name>">, @@ -4484,9 +4734,10 @@ def ast_dump_filter : Separate<["-"], "ast-dump-filter">, MarshallingInfoString<"FrontendOpts.ASTDumpFilter">; def fno_modules_global_index : Flag<["-"], "fno-modules-global-index">, HelpText<"Do not automatically generate or update the global module index">, - MarshallingInfoFlag<"FrontendOpts.UseGlobalModuleIndex", "true">, IsNegative; + MarshallingInfoNegativeFlag<"FrontendOpts.UseGlobalModuleIndex">; def fno_modules_error_recovery : Flag<["-"], "fno-modules-error-recovery">, - HelpText<"Do not automatically import modules for error recovery">; + HelpText<"Do not automatically import modules for error recovery">, + MarshallingInfoNegativeFlag<"LangOpts->ModulesErrorRecovery">; def fmodule_map_file_home_is_cwd : Flag<["-"], "fmodule-map-file-home-is-cwd">, HelpText<"Use the current working directory as the home directory of " "module maps specified by -fmodule-map-file=<FILE>">, @@ -4509,11 +4760,13 @@ def fmodules_local_submodule_visibility : def fmodules_codegen : Flag<["-"], "fmodules-codegen">, HelpText<"Generate code for uses of this module that assumes an explicit " - "object file will be built for the module">; + "object file will be built for the module">, + MarshallingInfoFlag<"LangOpts->ModulesCodegen">; def fmodules_debuginfo : Flag<["-"], "fmodules-debuginfo">, HelpText<"Generate debug info for types in an object file built from this " - "module and do not generate them elsewhere">; + "module and do not generate them elsewhere">, + MarshallingInfoFlag<"LangOpts->ModulesDebugInfo">; def fmodule_format_EQ : Joined<["-"], "fmodule-format=">, HelpText<"Select the container format for clang modules and PCH. " "Supported options are 'raw' and 'obj'.">, @@ -4526,15 +4779,19 @@ def fconcepts_ts : Flag<["-"], "fconcepts-ts">, HelpText<"Enable C++ Extensions for Concepts. (deprecated - use -std=c++2a)">; def fno_concept_satisfaction_caching : Flag<["-"], "fno-concept-satisfaction-caching">, - HelpText<"Disable satisfaction caching for C++2a Concepts.">; + HelpText<"Disable satisfaction caching for C++2a Concepts.">, + MarshallingInfoNegativeFlag<"LangOpts->ConceptSatisfactionCaching">; -def frecovery_ast : Flag<["-"], "frecovery-ast">, - HelpText<"Preserve expressions in AST rather than dropping them when " - "encountering semantic errors">; -def fno_recovery_ast : Flag<["-"], "fno-recovery-ast">; -def frecovery_ast_type : Flag<["-"], "frecovery-ast-type">, - HelpText<"Preserve the type for recovery expressions when possible">; -def fno_recovery_ast_type : Flag<["-"], "fno-recovery-ast-type">; +defm recovery_ast : BoolOption<"recovery-ast", + "LangOpts->RecoveryAST", DefaultsToTrue, + ChangedBy<NegFlag>, ResetBy<PosFlag, [], "Preserve expressions in AST rather " + "than dropping them when encountering semantic errors">, + BothFlags<[]>, "f">; +defm recovery_ast_type : BoolOption<"recovery-ast-type", + "LangOpts->RecoveryASTType", DefaultsToTrue, + ChangedBy<NegFlag>, ResetBy<PosFlag, [], "Preserve the type for recovery " + "expressions when possible">, + BothFlags<[]>, "f">; let Group = Action_Group in { @@ -4610,10 +4867,11 @@ def print_dependency_directives_minimized_source : Flag<["-"], HelpText<"Print the output of the dependency directives source minimizer">; } -def emit_llvm_uselists : Flag<["-"], "emit-llvm-uselists">, - HelpText<"Preserve order of LLVM use-lists when serializing">; -def no_emit_llvm_uselists : Flag<["-"], "no-emit-llvm-uselists">, - HelpText<"Don't preserve order of LLVM use-lists when serializing">; +defm emit_llvm_uselists : BoolOption<"emit-llvm-uselists", + "CodeGenOpts.EmitLLVMUseLists", DefaultsToFalse, + ChangedBy<PosFlag, [], "Preserve">, + ResetBy<NegFlag, [], "Don't preserve">, + BothFlags<[], " order of LLVM use-lists when serializing">>; def mt_migrate_directory : Separate<["-"], "mt-migrate-directory">, HelpText<"Directory for temporary files produced during ARC or ObjC migration">, @@ -4624,10 +4882,11 @@ def arcmt_action_EQ : Joined<["-"], "arcmt-action=">, Flags<[CC1Option, NoDriver NormalizedValuesScope<"FrontendOptions">, NormalizedValues<["ARCMT_Check", "ARCMT_Modify", "ARCMT_Migrate"]>, MarshallingInfoString<"FrontendOpts.ARCMTAction", "ARCMT_None">, - AutoNormalizeEnumJoined; + AutoNormalizeEnum; def opt_record_file : Separate<["-"], "opt-record-file">, - HelpText<"File name to use for YAML optimization record output">; + HelpText<"File name to use for YAML optimization record output">, + MarshallingInfoString<"CodeGenOpts.OptRecordFile">; def opt_record_passes : Separate<["-"], "opt-record-passes">, HelpText<"Only record remark information for passes whose names match the given regular expression">; def opt_record_format : Separate<["-"], "opt-record-format">, @@ -4642,7 +4901,8 @@ def stats_file : Joined<["-"], "stats-file=">, def fdump_record_layouts : Flag<["-"], "fdump-record-layouts">, HelpText<"Dump record layout information">; def fdump_record_layouts_simple : Flag<["-"], "fdump-record-layouts-simple">, - HelpText<"Dump record layout information in a simple form used for testing">; + HelpText<"Dump record layout information in a simple form used for testing">, + MarshallingInfoFlag<"LangOpts->DumpRecordLayoutsSimple">; def fix_what_you_can : Flag<["-"], "fix-what-you-can">, HelpText<"Apply fix-it advice even in the presence of unfixable errors">, MarshallingInfoFlag<"FrontendOpts.FixWhatYouCan">; @@ -4670,9 +4930,10 @@ def pch_through_hdrstop_use : Flag<["-"], "pch-through-hdrstop-use">, HelpText<"When using a PCH, skip tokens until after a #pragma hdrstop.">; def fno_pch_timestamp : Flag<["-"], "fno-pch-timestamp">, HelpText<"Disable inclusion of timestamp in precompiled headers">, - MarshallingInfoFlag<"FrontendOpts.IncludeTimestamps", "true">, IsNegative; + MarshallingInfoNegativeFlag<"FrontendOpts.IncludeTimestamps">; def building_pch_with_obj : Flag<["-"], "building-pch-with-obj">, - HelpText<"This compilation is part of building a PCH with corresponding object file.">; + HelpText<"This compilation is part of building a PCH with corresponding object file.">, + MarshallingInfoFlag<"LangOpts->BuildingPCHWithObjectFile">; def aligned_alloc_unavailable : Flag<["-"], "faligned-alloc-unavailable">, HelpText<"Aligned allocation/deallocation functions are unavailable">; @@ -4687,23 +4948,29 @@ def version : Flag<["-"], "version">, HelpText<"Print the compiler version">, MarshallingInfoFlag<"FrontendOpts.ShowVersion">; def main_file_name : Separate<["-"], "main-file-name">, - HelpText<"Main file name to use for debug info and source if missing">; + HelpText<"Main file name to use for debug info and source if missing">, + MarshallingInfoString<"CodeGenOpts.MainFileName">; def split_dwarf_output : Separate<["-"], "split-dwarf-output">, - HelpText<"File name to use for split dwarf debug info output">; + HelpText<"File name to use for split dwarf debug info output">, + MarshallingInfoString<"CodeGenOpts.SplitDwarfOutput">; } def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">, - HelpText<"Weakly link in the blocks runtime">; + HelpText<"Weakly link in the blocks runtime">, + MarshallingInfoFlag<"LangOpts->BlocksRuntimeOptional">; def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">, - HelpText<"Assume all functions with C linkage do not unwind">; + HelpText<"Assume all functions with C linkage do not unwind">, + MarshallingInfoFlag<"LangOpts->ExternCNoUnwind">; def split_dwarf_file : Separate<["-"], "split-dwarf-file">, - HelpText<"Name of the split dwarf debug info file to encode in the object file">; + HelpText<"Name of the split dwarf debug info file to encode in the object file">, + MarshallingInfoString<"CodeGenOpts.SplitDwarfFile">; def fno_wchar : Flag<["-"], "fno-wchar">, HelpText<"Disable C++ builtin type wchar_t">; def fconstant_string_class : Separate<["-"], "fconstant-string-class">, MetaVarName<"<class name>">, - HelpText<"Specify the class to use for constant Objective-C string objects.">; + HelpText<"Specify the class to use for constant Objective-C string objects.">, + MarshallingInfoString<"LangOpts->ObjCConstantStringClass">; def fobjc_arc_cxxlib_EQ : Joined<["-"], "fobjc-arc-cxxlib=">, HelpText<"Objective-C++ Automatic Reference Counting standard library kind">, Values<"libc++,libstdc++,none">, NormalizedValues<["ARCXX_libcxx", "ARCXX_libstdcxx", "ARCXX_nolib"]>, @@ -4711,19 +4978,26 @@ def fobjc_arc_cxxlib_EQ : Joined<["-"], "fobjc-arc-cxxlib=">, def fobjc_runtime_has_weak : Flag<["-"], "fobjc-runtime-has-weak">, HelpText<"The target Objective-C runtime supports ARC weak operations">; def fobjc_dispatch_method_EQ : Joined<["-"], "fobjc-dispatch-method=">, - HelpText<"Objective-C dispatch method to use">, Values<"legacy,non-legacy,mixed">; + HelpText<"Objective-C dispatch method to use">, Values<"legacy,non-legacy,mixed">, + NormalizedValuesScope<"CodeGenOptions">, NormalizedValues<["Legacy", "NonLegacy", "Mixed"]>, + MarshallingInfoString<"CodeGenOpts.ObjCDispatchMethod", "Legacy">, AutoNormalizeEnum; def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">, - HelpText<"disable the default synthesis of Objective-C properties">; + HelpText<"disable the default synthesis of Objective-C properties">, + MarshallingInfoNegativeFlag<"LangOpts->ObjCDefaultSynthProperties">; def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">, - HelpText<"enable extended encoding of block type signature">; + HelpText<"enable extended encoding of block type signature">, + MarshallingInfoFlag<"LangOpts->EncodeExtendedBlockSig">; def function_alignment : Separate<["-"], "function-alignment">, - HelpText<"default alignment for functions">; + HelpText<"default alignment for functions">, + MarshallingInfoStringInt<"LangOpts->FunctionAlignment">; def pic_level : Separate<["-"], "pic-level">, HelpText<"Value for __PIC__">; def pic_is_pie : Flag<["-"], "pic-is-pie">, - HelpText<"File is for a position independent executable">; + HelpText<"File is for a position independent executable">, + MarshallingInfoFlag<"LangOpts->PIE">; def fhalf_no_semantic_interposition : Flag<["-"], "fhalf-no-semantic-interposition">, - HelpText<"Like -fno-semantic-interposition but don't use local aliases">; + HelpText<"Like -fno-semantic-interposition but don't use local aliases">, + MarshallingInfoFlag<"LangOpts->HalfNoSemanticInterposition">; def fno_validate_pch : Flag<["-"], "fno-validate-pch">, HelpText<"Disable validation of precompiled headers">, MarshallingInfoFlag<"PreprocessorOpts->DisablePCHValidation">; @@ -4739,53 +5013,79 @@ def error_on_deserialized_pch_decl : Separate<["-"], "error-on-deserialized-decl def error_on_deserialized_pch_decl_EQ : Joined<["-"], "error-on-deserialized-decl=">, Alias<error_on_deserialized_pch_decl>; def static_define : Flag<["-"], "static-define">, - HelpText<"Should __STATIC__ be defined">; + HelpText<"Should __STATIC__ be defined">, + MarshallingInfoFlag<"LangOpts->Static">; def stack_protector : Separate<["-"], "stack-protector">, - HelpText<"Enable stack protectors">; + HelpText<"Enable stack protectors">, Values<"0,1,2,3">, + NormalizedValuesScope<"LangOptions">, + NormalizedValues<["SSPOff", "SSPOn", "SSPStrong", "SSPReq"]>, + MarshallingInfoString<"LangOpts->StackProtector", "SSPOff">, AutoNormalizeEnum; def stack_protector_buffer_size : Separate<["-"], "stack-protector-buffer-size">, - HelpText<"Lower bound for a buffer to be considered for stack protection">; + HelpText<"Lower bound for a buffer to be considered for stack protection">, + MarshallingInfoStringInt<"CodeGenOpts.SSPBufferSize", "8">; +// FIXME: diagnose if target does not support protected visibility +// Good place for this is CompilerInvocation::fixupInvocation. Do the same for parseVisibility. def fvisibility : Separate<["-"], "fvisibility">, - HelpText<"Default type and symbol visibility">; + HelpText<"Default type and symbol visibility">, Values<"default,hidden,internal,protected">, + NormalizedValues<["DefaultVisibility", "HiddenVisibility", "HiddenVisibility", "ProtectedVisibility"]>, + MarshallingInfoString<"LangOpts->ValueVisibilityMode", "DefaultVisibility">, AutoNormalizeEnum; def ftype_visibility : Separate<["-"], "ftype-visibility">, HelpText<"Default type visibility">; def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">, - HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">; + HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">, + MarshallingInfoFlag<"LangOpts->SetVisibilityForExternDecls">; def ftemplate_depth : Separate<["-"], "ftemplate-depth">, - HelpText<"Maximum depth of recursive template instantiation">; + HelpText<"Maximum depth of recursive template instantiation">, + MarshallingInfoStringInt<"LangOpts->InstantiationDepth", "1024">; def foperator_arrow_depth : Separate<["-"], "foperator-arrow-depth">, - HelpText<"Maximum number of 'operator->'s to call for a member access">; + HelpText<"Maximum number of 'operator->'s to call for a member access">, + MarshallingInfoStringInt<"LangOpts->ArrowDepth", "256">; def fconstexpr_depth : Separate<["-"], "fconstexpr-depth">, - HelpText<"Maximum depth of recursive constexpr function calls">; + HelpText<"Maximum depth of recursive constexpr function calls">, + MarshallingInfoStringInt<"LangOpts->ConstexprCallDepth", "512">; def fconstexpr_steps : Separate<["-"], "fconstexpr-steps">, - HelpText<"Maximum number of steps in constexpr function evaluation">; + HelpText<"Maximum number of steps in constexpr function evaluation">, + MarshallingInfoStringInt<"LangOpts->ConstexprStepLimit", "1048576">; def fbracket_depth : Separate<["-"], "fbracket-depth">, - HelpText<"Maximum nesting level for parentheses, brackets, and braces">; -def fconst_strings : Flag<["-"], "fconst-strings">, - HelpText<"Use a const qualified type for string literals in C and ObjC">; -def fno_const_strings : Flag<["-"], "fno-const-strings">, - HelpText<"Don't use a const qualified type for string literals in C and ObjC">; + HelpText<"Maximum nesting level for parentheses, brackets, and braces">, + MarshallingInfoStringInt<"LangOpts->BracketDepth", "256">; +defm const_strings : BoolCC1Option<"const-strings", + "LangOpts->ConstStrings", DefaultsToFalse, + ChangedBy<PosFlag, [], "Use">, ResetBy<NegFlag, [], "Don't use">, + BothFlags<[], " a const qualified type for string literals in C and ObjC">, "f">; def fno_bitfield_type_align : Flag<["-"], "fno-bitfield-type-align">, - HelpText<"Ignore bit-field types when aligning structures">; + HelpText<"Ignore bit-field types when aligning structures">, + MarshallingInfoFlag<"LangOpts->NoBitFieldTypeAlign">; def ffake_address_space_map : Flag<["-"], "ffake-address-space-map">, - HelpText<"Use a fake address space map; OpenCL testing purposes only">; + HelpText<"Use a fake address space map; OpenCL testing purposes only">, + MarshallingInfoFlag<"LangOpts->FakeAddressSpaceMap">; def faddress_space_map_mangling_EQ : Joined<["-"], "faddress-space-map-mangling=">, MetaVarName<"<yes|no|target>">, - HelpText<"Set the mode for address space map based mangling; OpenCL testing purposes only">; + HelpText<"Set the mode for address space map based mangling; OpenCL testing purposes only">, + Values<"target,no,yes">, NormalizedValuesScope<"LangOptions">, + NormalizedValues<["ASMM_Target", "ASMM_Off", "ASMM_On"]>, + MarshallingInfoString<"LangOpts->AddressSpaceMapMangling", "ASMM_Target">, AutoNormalizeEnum; def funknown_anytype : Flag<["-"], "funknown-anytype">, - HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">; + HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">, + MarshallingInfoFlag<"LangOpts->ParseUnknownAnytype">; def fdebugger_support : Flag<["-"], "fdebugger-support">, - HelpText<"Enable special debugger support behavior">; + HelpText<"Enable special debugger support behavior">, + MarshallingInfoFlag<"LangOpts->DebuggerSupport">; def fdebugger_cast_result_to_id : Flag<["-"], "fdebugger-cast-result-to-id">, - HelpText<"Enable casting unknown expression results to id">; + HelpText<"Enable casting unknown expression results to id">, + MarshallingInfoFlag<"LangOpts->DebuggerCastResultToId">; def fdebugger_objc_literal : Flag<["-"], "fdebugger-objc-literal">, - HelpText<"Enable special debugger support for Objective-C subscripting and literals">; + HelpText<"Enable special debugger support for Objective-C subscripting and literals">, + MarshallingInfoFlag<"LangOpts->DebuggerObjCLiteral">; def fdeprecated_macro : Flag<["-"], "fdeprecated-macro">, HelpText<"Defines the __DEPRECATED macro">; def fno_deprecated_macro : Flag<["-"], "fno-deprecated-macro">, HelpText<"Undefines the __DEPRECATED macro">; def fobjc_subscripting_legacy_runtime : Flag<["-"], "fobjc-subscripting-legacy-runtime">, HelpText<"Allow Objective-C array and dictionary subscripting in legacy runtime">; +// TODO: Enforce values valid for MSVtorDispMode. def vtordisp_mode_EQ : Joined<["-"], "vtordisp-mode=">, - HelpText<"Control vtordisp placement on win32 targets">; + HelpText<"Control vtordisp placement on win32 targets">, + MarshallingInfoStringInt<"LangOpts->VtorDispMode", "1">; def fnative_half_type: Flag<["-"], "fnative-half-type">, HelpText<"Use the native half type for __fp16 instead of promoting to float">; def fnative_half_arguments_and_returns : Flag<["-"], "fnative-half-arguments-and-returns">, @@ -4793,25 +5093,35 @@ def fnative_half_arguments_and_returns : Flag<["-"], "fnative-half-arguments-and def fallow_half_arguments_and_returns : Flag<["-"], "fallow-half-arguments-and-returns">, HelpText<"Allow function arguments and returns of type half">; def fdefault_calling_conv_EQ : Joined<["-"], "fdefault-calling-conv=">, - HelpText<"Set default calling convention">, Values<"cdecl,fastcall,stdcall,vectorcall,regcall">; + HelpText<"Set default calling convention">, Values<"cdecl,fastcall,stdcall,vectorcall,regcall">, + NormalizedValuesScope<"LangOptions">, + NormalizedValues<["DCC_CDecl", "DCC_FastCall", "DCC_StdCall", "DCC_VectorCall", "DCC_RegCall"]>, + MarshallingInfoString<"LangOpts->DefaultCallingConv", "DCC_None">, AutoNormalizeEnum; def finclude_default_header : Flag<["-"], "finclude-default-header">, - HelpText<"Include default header file for OpenCL">; + HelpText<"Include default header file for OpenCL">, + MarshallingInfoFlag<"LangOpts->IncludeDefaultHeader">; def fdeclare_opencl_builtins : Flag<["-"], "fdeclare-opencl-builtins">, - HelpText<"Add OpenCL builtin function declarations (experimental)">; + HelpText<"Add OpenCL builtin function declarations (experimental)">, + MarshallingInfoFlag<"LangOpts->DeclareOpenCLBuiltins">; def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">, - HelpText<"Preserve 3-component vector type">; + HelpText<"Preserve 3-component vector type">, + MarshallingInfoFlag<"CodeGenOpts.PreserveVec3Type">; def fwchar_type_EQ : Joined<["-"], "fwchar-type=">, - HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">; -def fsigned_wchar : Flag<["-"], "fsigned-wchar">, - HelpText<"Use a signed type for wchar_t">; -def fno_signed_wchar : Flag<["-"], "fno-signed-wchar">, - HelpText<"Use an unsigned type for wchar_t">; + HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">, + NormalizedValues<["1", "2", "4"]>, + MarshallingInfoString<"LangOpts->WCharSize", "0">, AutoNormalizeEnum; +defm signed_wchar : BoolCC1Option<"signed-wchar", + "LangOpts->WCharIsSigned", DefaultsToTrue, + ChangedBy<NegFlag, [], "Use an unsigned">, ResetBy<PosFlag, [], "Use a signed">, + BothFlags<[], " type for wchar_t">, "f">; def fcompatibility_qualified_id_block_param_type_checking : Flag<["-"], "fcompatibility-qualified-id-block-type-checking">, HelpText<"Allow using blocks with parameters of more specific type than " - "the type system guarantees when a parameter is qualified id">; + "the type system guarantees when a parameter is qualified id">, + MarshallingInfoFlag<"LangOpts->CompatibilityQualifiedIdBlockParamTypeChecking">; def fpass_by_value_is_noalias: Flag<["-"], "fpass-by-value-is-noalias">, HelpText<"Allows assuming by-value parameters do not alias any other value. " - "Has no effect on non-trivially-copyable classes in C++.">, Group<f_Group>; + "Has no effect on non-trivially-copyable classes in C++.">, Group<f_Group>, + MarshallingInfoFlag<"CodeGenOpts.PassByValueIsNoAlias">; // FIXME: Remove these entirely once functionality/tests have been excised. def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>, @@ -4825,7 +5135,7 @@ def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>, def nostdsysteminc : Flag<["-"], "nostdsysteminc">, HelpText<"Disable standard system #include directories">, - MarshallingInfoFlag<"HeaderSearchOpts->UseStandardSystemIncludes", "true">, IsNegative; + MarshallingInfoNegativeFlag<"HeaderSearchOpts->UseStandardSystemIncludes">; def fdisable_module_hash : Flag<["-"], "fdisable-module-hash">, HelpText<"Disable the module hash">, MarshallingInfoFlag<"HeaderSearchOpts->DisableModuleHash">; @@ -4887,13 +5197,17 @@ def cl_ext_EQ : CommaJoined<["-"], "cl-ext=">, //===----------------------------------------------------------------------===// def fcuda_is_device : Flag<["-"], "fcuda-is-device">, - HelpText<"Generate code for CUDA device">; + HelpText<"Generate code for CUDA device">, + MarshallingInfoFlag<"LangOpts->CUDAIsDevice">; def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">, - HelpText<"Incorporate CUDA device-side binary into host object file.">; + HelpText<"Incorporate CUDA device-side binary into host object file.">, + MarshallingInfoString<"CodeGenOpts.CudaGpuBinaryFileName">; def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">, - HelpText<"Allow variadic functions in CUDA device code.">; + HelpText<"Allow variadic functions in CUDA device code.">, + MarshallingInfoFlag<"LangOpts->CUDAAllowVariadicFunctions">; def fno_cuda_host_device_constexpr : Flag<["-"], "fno-cuda-host-device-constexpr">, - HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">; + HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">, + MarshallingInfoNegativeFlag<"LangOpts->CUDAHostDeviceConstexpr">; //===----------------------------------------------------------------------===// // OpenMP Options diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp index 30d61bf..f9bce6a 100644 --- a/clang/lib/Frontend/CompilerInvocation.cpp +++ b/clang/lib/Frontend/CompilerInvocation.cpp @@ -152,8 +152,8 @@ static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, /// argument. static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args, const char *Spelling, - CompilerInvocation::StringAllocator, unsigned, - /*T*/...) { + CompilerInvocation::StringAllocator, + Option::OptionClass, unsigned, /*T*/...) { Args.push_back(Spelling); } @@ -193,12 +193,41 @@ static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, static auto makeBooleanOptionDenormalizer(bool Value) { return [Value](SmallVectorImpl<const char *> &Args, const char *Spelling, - CompilerInvocation::StringAllocator, unsigned, bool KeyPath) { + CompilerInvocation::StringAllocator, Option::OptionClass, + unsigned, bool KeyPath) { if (KeyPath == Value) Args.push_back(Spelling); }; } +static void denormalizeStringImpl(SmallVectorImpl<const char *> &Args, + const char *Spelling, + CompilerInvocation::StringAllocator SA, + Option::OptionClass OptClass, unsigned, + Twine Value) { + switch (OptClass) { + case Option::SeparateClass: + case Option::JoinedOrSeparateClass: + Args.push_back(Spelling); + Args.push_back(SA(Value)); + break; + case Option::JoinedClass: + Args.push_back(SA(Twine(Spelling) + Value)); + break; + default: + llvm_unreachable("Cannot denormalize an option with option class " + "incompatible with string denormalization."); + } +} + +template <typename T> +static void +denormalizeString(SmallVectorImpl<const char *> &Args, const char *Spelling, + CompilerInvocation::StringAllocator SA, + Option::OptionClass OptClass, unsigned TableIndex, T Value) { + denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value)); +} + static Optional<SimpleEnumValue> findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) { for (int I = 0, E = Table.Size; I != E; ++I) @@ -240,12 +269,13 @@ static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt, static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args, const char *Spelling, CompilerInvocation::StringAllocator SA, + Option::OptionClass OptClass, unsigned TableIndex, unsigned Value) { assert(TableIndex < SimpleEnumValueTablesSize); const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex]; if (auto MaybeEnumVal = findValueTableByValue(Table, Value)) { - Args.push_back(Spelling); - Args.push_back(MaybeEnumVal->Name); + denormalizeString(Args, Spelling, SA, OptClass, TableIndex, + MaybeEnumVal->Name); } else { llvm_unreachable("The simple enum value was not correctly defined in " "the tablegen option description"); @@ -256,24 +286,12 @@ template <typename T> static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args, const char *Spelling, CompilerInvocation::StringAllocator SA, + Option::OptionClass OptClass, unsigned TableIndex, T Value) { - return denormalizeSimpleEnumImpl(Args, Spelling, SA, TableIndex, + return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex, static_cast<unsigned>(Value)); } -static void denormalizeSimpleEnumJoined(SmallVectorImpl<const char *> &Args, - const char *Spelling, - CompilerInvocation::StringAllocator SA, - unsigned TableIndex, unsigned Value) { - assert(TableIndex < SimpleEnumValueTablesSize); - const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex]; - if (auto MaybeEnumVal = findValueTableByValue(Table, Value)) - Args.push_back(SA(Twine(Spelling) + MaybeEnumVal->Name)); - else - llvm_unreachable("The simple enum value was not correctly defined in " - "the tablegen option description"); -} - static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags) { @@ -283,25 +301,6 @@ static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex, return std::string(Arg->getValue()); } -static void denormalizeString(SmallVectorImpl<const char *> &Args, - const char *Spelling, - CompilerInvocation::StringAllocator SA, unsigned, - Twine Value) { - Args.push_back(Spelling); - Args.push_back(SA(Value)); -} - -template <typename T, - std::enable_if_t<!std::is_convertible<T, Twine>::value && - std::is_constructible<Twine, T>::value, - bool> = false> -static void denormalizeString(SmallVectorImpl<const char *> &Args, - const char *Spelling, - CompilerInvocation::StringAllocator SA, - unsigned TableIndex, T Value) { - denormalizeString(Args, Spelling, SA, TableIndex, Twine(Value)); -} - template <typename IntTy> static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args, @@ -317,6 +316,23 @@ static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int, return Res; } +static Optional<std::vector<std::string>> +normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, + DiagnosticsEngine &) { + return Args.getAllArgValues(Opt); +} + +static void denormalizeStringVector(SmallVectorImpl<const char *> &Args, + const char *Spelling, + CompilerInvocation::StringAllocator SA, + Option::OptionClass OptClass, + unsigned TableIndex, + const std::vector<std::string> &Values) { + for (const std::string &Value : Values) { + denormalizeString(Args, Spelling, SA, OptClass, TableIndex, Value); + } +} + static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags) { @@ -345,7 +361,8 @@ static T extractMaskValue(T KeyPath) { } static void FixupInvocation(CompilerInvocation &Invocation, - DiagnosticsEngine &Diags) { + DiagnosticsEngine &Diags, + const InputArgList &Args) { LangOptions &LangOpts = *Invocation.getLangOpts(); DiagnosticOptions &DiagOpts = Invocation.getDiagnosticOpts(); CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts(); @@ -354,16 +371,52 @@ static void FixupInvocation(CompilerInvocation &Invocation, CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument; CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents; CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents; + CodeGenOpts.DisableFree = FrontendOpts.DisableFree; FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex; + LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables; + LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening; + LangOpts.CurrentModule = LangOpts.ModuleName; + llvm::sys::Process::UseANSIEscapeCodes(DiagOpts.UseANSIEscapeCodes); llvm::Triple T(TargetOpts.Triple); + llvm::Triple::ArchType Arch = T.getArch(); if (LangOpts.getExceptionHandling() != llvm::ExceptionHandling::None && T.isWindowsMSVCEnvironment()) Diags.Report(diag::err_fe_invalid_exception_model) << static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str(); + + if (LangOpts.AppleKext && !LangOpts.CPlusPlus) + Diags.Report(diag::warn_c_kext); + + if (LangOpts.NewAlignOverride && + !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) { + Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ); + Diags.Report(diag::err_fe_invalid_alignment) + << A->getAsString(Args) << A->getValue(); + LangOpts.NewAlignOverride = 0; + } + + if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) { + auto DefaultCC = LangOpts.getDefaultCallingConv(); + + bool emitError = (DefaultCC == LangOptions::DCC_FastCall || + DefaultCC == LangOptions::DCC_StdCall) && + Arch != llvm::Triple::x86; + emitError |= (DefaultCC == LangOptions::DCC_VectorCall || + DefaultCC == LangOptions::DCC_RegCall) && + !T.isX86(); + if (emitError) + Diags.Report(diag::err_drv_argument_not_allowed_with) + << A->getSpelling() << T.getTriple(); + } + + if (!CodeGenOpts.ProfileRemappingFile.empty() && CodeGenOpts.LegacyPassManager) + Diags.Report(diag::err_drv_argument_only_allowed_with) + << Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args) + << "-fno-legacy-pass-manager"; } //===----------------------------------------------------------------------===// @@ -806,28 +859,6 @@ static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, } } -// Set the profile kind for fprofile-instrument. -static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args, - DiagnosticsEngine &Diags) { - Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ); - if (A == nullptr) - return; - StringRef S = A->getValue(); - unsigned I = llvm::StringSwitch<unsigned>(S) - .Case("none", CodeGenOptions::ProfileNone) - .Case("clang", CodeGenOptions::ProfileClangInstr) - .Case("llvm", CodeGenOptions::ProfileIRInstr) - .Case("csllvm", CodeGenOptions::ProfileCSIRInstr) - .Default(~0U); - if (I == ~0U) { - Diags.Report(diag::err_drv_invalid_pgo_instrumentor) << A->getAsString(Args) - << S; - return; - } - auto Instrumentor = static_cast<CodeGenOptions::ProfileInstrKind>(I); - Opts.setProfileInstr(Instrumentor); -} - // Set the profile kind using fprofile-instrument-use-path. static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName) { @@ -889,87 +920,18 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, } } - if (Arg *A = Args.getLastArg(OPT_fveclib)) { - StringRef Name = A->getValue(); - if (Name == "Accelerate") - Opts.setVecLib(CodeGenOptions::Accelerate); - else if (Name == "libmvec") - Opts.setVecLib(CodeGenOptions::LIBMVEC); - else if (Name == "MASSV") - Opts.setVecLib(CodeGenOptions::MASSV); - else if (Name == "SVML") - Opts.setVecLib(CodeGenOptions::SVML); - else if (Name == "none") - Opts.setVecLib(CodeGenOptions::NoLibrary); - else - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; - } - - if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) { - unsigned Val = - llvm::StringSwitch<unsigned>(A->getValue()) - .Case("line-tables-only", codegenoptions::DebugLineTablesOnly) - .Case("line-directives-only", codegenoptions::DebugDirectivesOnly) - .Case("constructor", codegenoptions::DebugInfoConstructor) - .Case("limited", codegenoptions::LimitedDebugInfo) - .Case("standalone", codegenoptions::FullDebugInfo) - .Case("unused-types", codegenoptions::UnusedTypeInfo) - .Default(~0U); - if (Val == ~0U) - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) - << A->getValue(); - else - Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val)); - } // If -fuse-ctor-homing is set and limited debug info is already on, then use // constructor homing. if (Args.getLastArg(OPT_fuse_ctor_homing)) if (Opts.getDebugInfo() == codegenoptions::LimitedDebugInfo) Opts.setDebugInfo(codegenoptions::DebugInfoConstructor); - if (Arg *A = Args.getLastArg(OPT_debugger_tuning_EQ)) { - unsigned Val = llvm::StringSwitch<unsigned>(A->getValue()) - .Case("gdb", unsigned(llvm::DebuggerKind::GDB)) - .Case("lldb", unsigned(llvm::DebuggerKind::LLDB)) - .Case("sce", unsigned(llvm::DebuggerKind::SCE)) - .Default(~0U); - if (Val == ~0U) - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) - << A->getValue(); - else - Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val)); - } - Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags); - Opts.DebugColumnInfo = !Args.hasArg(OPT_gno_column_info); - Opts.EmitCodeView = Args.hasArg(OPT_gcodeview); - Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro); - Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables); - Opts.VirtualFunctionElimination = - Args.hasArg(OPT_fvirtual_function_elimination); - Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std); - Opts.SplitDwarfFile = std::string(Args.getLastArgValue(OPT_split_dwarf_file)); - Opts.SplitDwarfOutput = - std::string(Args.getLastArgValue(OPT_split_dwarf_output)); - Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining); - Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs); - Opts.DebugExplicitImport = Args.hasArg(OPT_dwarf_explicit_import); - Opts.DebugFwdTemplateParams = Args.hasArg(OPT_debug_forward_template_params); - Opts.EmbedSource = Args.hasArg(OPT_gembed_source); - Opts.ForceDwarfFrameSection = Args.hasArg(OPT_fforce_dwarf_frame); - for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) { auto Split = StringRef(Arg).split('='); Opts.DebugPrefixMap.insert( {std::string(Split.first), std::string(Split.second)}); } - if (const Arg *A = - Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists)) - Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists; - - Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes); - Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers); - const llvm::Triple::ArchType DebugEntryValueArchs[] = { llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64, llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips, @@ -980,29 +942,8 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, llvm::is_contained(DebugEntryValueArchs, T.getArch())) Opts.EmitCallSiteInfo = true; - Opts.ValueTrackingVariableLocations = - Args.hasArg(OPT_fexperimental_debug_variable_locations); - - Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone); - Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone); - Opts.IndirectTlsSegRefs = Args.hasArg(OPT_mno_tls_direct_seg_refs); - Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables); - Opts.UseRegisterSizedBitfieldAccess = Args.hasArg( - OPT_fuse_register_sized_bitfield_access); - Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing); - Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa); Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) && Args.hasArg(OPT_new_struct_path_tbaa); - Opts.FineGrainedBitfieldAccesses = - Args.hasFlag(OPT_ffine_grained_bitfield_accesses, - OPT_fno_fine_grained_bitfield_accesses, false); - Opts.DwarfDebugFlags = - std::string(Args.getLastArgValue(OPT_dwarf_debug_flags)); - Opts.RecordCommandLine = - std::string(Args.getLastArgValue(OPT_record_command_line)); - Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants); - Opts.NoCommon = !Args.hasArg(OPT_fcommon); - Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float); Opts.OptimizeSize = getOptimizationLevelSize(Args); Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) || Args.hasArg(OPT_ffreestanding)); @@ -1011,73 +952,18 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Opts.UnrollLoops = Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops, (Opts.OptimizationLevel > 1)); - Opts.RerollLoops = Args.hasArg(OPT_freroll_loops); - - Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as); - Opts.SampleProfileFile = - std::string(Args.getLastArgValue(OPT_fprofile_sample_use_EQ)); - Opts.DebugInfoForProfiling = Args.hasFlag( - OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false); - Opts.PseudoProbeForProfiling = - Args.hasFlag(OPT_fpseudo_probe_for_profiling, - OPT_fno_pseudo_probe_for_profiling, false); + Opts.DebugNameTable = static_cast<unsigned>( Args.hasArg(OPT_ggnu_pubnames) ? llvm::DICompileUnit::DebugNameTableKind::GNU : Args.hasArg(OPT_gpubnames) ? llvm::DICompileUnit::DebugNameTableKind::Default : llvm::DICompileUnit::DebugNameTableKind::None); - Opts.DebugRangesBaseAddress = Args.hasArg(OPT_fdebug_ranges_base_address); - - setPGOInstrumentor(Opts, Args, Diags); - Opts.AtomicProfileUpdate = Args.hasArg(OPT_fprofile_update_EQ); - Opts.InstrProfileOutput = - std::string(Args.getLastArgValue(OPT_fprofile_instrument_path_EQ)); - Opts.ProfileInstrumentUsePath = - std::string(Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ)); + if (!Opts.ProfileInstrumentUsePath.empty()) setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath); - Opts.ProfileRemappingFile = - std::string(Args.getLastArgValue(OPT_fprofile_remapping_file_EQ)); - if (!Opts.ProfileRemappingFile.empty() && Opts.LegacyPassManager) { - Diags.Report(diag::err_drv_argument_only_allowed_with) - << Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args) - << "-fno-legacy-pass-manager"; - } - Opts.CoverageMapping = - Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false); - Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping); - Opts.AsmVerbose = !Args.hasArg(OPT_fno_verbose_asm); - Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments); - Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new); - Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions); - Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit); - Opts.RegisterGlobalDtorsWithAtExit = - Args.hasArg(OPT_fregister_global_dtors_with_atexit); - Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases); Opts.CodeModel = TargetOpts.CodeModel; - Opts.DebugPass = std::string(Args.getLastArgValue(OPT_mdebug_pass)); - - // Handle -mframe-pointer option. - if (Arg *A = Args.getLastArg(OPT_mframe_pointer_EQ)) { - CodeGenOptions::FramePointerKind FP; - StringRef Name = A->getValue(); - bool ValidFP = true; - if (Name == "none") - FP = CodeGenOptions::FramePointerKind::None; - else if (Name == "non-leaf") - FP = CodeGenOptions::FramePointerKind::NonLeaf; - else if (Name == "all") - FP = CodeGenOptions::FramePointerKind::All; - else { - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; - Success = false; - ValidFP = false; - } - if (ValidFP) - Opts.setFramePointer(FP); - } if (const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) { Opts.TimePasses = true; @@ -1099,69 +985,13 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, } } - Opts.DisableFree = Args.hasArg(OPT_disable_free); - Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names); - Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls); - Opts.NoEscapingBlockTailCalls = - Args.hasArg(OPT_fno_escaping_block_tail_calls); - Opts.FloatABI = std::string(Args.getLastArgValue(OPT_mfloat_abi)); - Opts.LimitFloatPrecision = - std::string(Args.getLastArgValue(OPT_mlimit_float_precision)); Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ); - Opts.StrictFloatCastOverflow = - !Args.hasArg(OPT_fno_strict_float_cast_overflow); - - Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_fno_zero_initialized_in_bss); - Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags); - Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack); - Opts.SmallDataLimit = - getLastArgIntValue(Args, OPT_msmall_data_limit, 0, Diags); - Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings); - Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn); - Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks); - Opts.RelaxAll = Args.hasArg(OPT_mrelax_all); - Opts.IncrementalLinkerCompatible = - Args.hasArg(OPT_mincremental_linker_compatible); - Opts.PIECopyRelocations = - Args.hasArg(OPT_mpie_copy_relocations); - Opts.NoPLT = Args.hasArg(OPT_fno_plt); - Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels); - Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm); - Opts.SoftFloat = Args.hasArg(OPT_msoft_float); - Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums); - Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return); - Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers); - Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables); - Opts.UnwindTables = Args.hasArg(OPT_munwind_tables); - Opts.TrapFuncName = std::string(Args.getLastArgValue(OPT_ftrap_function_EQ)); - Opts.UseInitArray = !Args.hasArg(OPT_fno_use_init_array); - - Opts.BBSections = - std::string(Args.getLastArgValue(OPT_fbasic_block_sections_EQ, "none")); // Basic Block Sections implies Function Sections. Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections) || (Opts.BBSections != "none" && Opts.BBSections != "labels"); - Opts.DataSections = Args.hasArg(OPT_fdata_sections); - Opts.StackSizeSection = Args.hasArg(OPT_fstack_size_section); - Opts.UniqueSectionNames = !Args.hasArg(OPT_fno_unique_section_names); - Opts.UniqueBasicBlockSectionNames = - Args.hasArg(OPT_funique_basic_block_section_names); - Opts.UniqueInternalLinkageNames = - Args.hasArg(OPT_funique_internal_linkage_names); - - Opts.SplitMachineFunctions = Args.hasArg(OPT_fsplit_machine_functions); - - Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions); - - Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables); - - Opts.NullPointerIsValid = Args.hasArg(OPT_fno_delete_null_pointer_checks); - - Opts.ProfileSampleAccurate = Args.hasArg(OPT_fprofile_sample_accurate); - Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ); Opts.PrepareForThinLTO = false; if (Arg *A = Args.getLastArg(OPT_flto_EQ)) { @@ -1171,8 +1001,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, else if (S != "full") Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S; } - Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false); - Opts.EnableSplitLTOUnit = Args.hasArg(OPT_fsplit_lto_unit); if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) { if (IK.getLanguage() != Language::LLVM_IR) Diags.Report(diag::err_drv_argument_only_allowed_with) @@ -1186,9 +1014,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, .Case("obj", FrontendOpts.OutputFile) .Default(llvm::sys::path::filename(FrontendOpts.OutputFile).str()); - Opts.ThinLinkBitcodeFile = - std::string(Args.getLastArgValue(OPT_fthin_link_bitcode_EQ)); - // The memory profile runtime appends the pid to make this name more unique. const char *MemProfileBasename = "memprof.profraw"; if (Args.hasArg(OPT_fmemory_profile_EQ)) { @@ -1199,22 +1024,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, } else if (Args.hasArg(OPT_fmemory_profile)) Opts.MemoryProfileOutput = MemProfileBasename; - Opts.MSVolatile = Args.hasArg(OPT_fms_volatile); - - Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops); - Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp); - - Opts.PreferVectorWidth = - std::string(Args.getLastArgValue(OPT_mprefer_vector_width_EQ)); - - Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name)); - Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier); - - Opts.ControlFlowGuardNoChecks = Args.hasArg(OPT_cfguard_no_checks); - Opts.ControlFlowGuard = Args.hasArg(OPT_cfguard); - - Opts.EmitGcovNotes = Args.hasArg(OPT_ftest_coverage); - Opts.EmitGcovArcs = Args.hasArg(OPT_fprofile_arcs); if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) { Opts.CoverageDataFile = std::string(Args.getLastArgValue(OPT_coverage_data_file)); @@ -1235,22 +1044,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, } } } - // Handle -fembed-bitcode option. - if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) { - StringRef Name = A->getValue(); - unsigned Model = llvm::StringSwitch<unsigned>(Name) - .Case("off", CodeGenOptions::Embed_Off) - .Case("all", CodeGenOptions::Embed_All) - .Case("bitcode", CodeGenOptions::Embed_Bitcode) - .Case("marker", CodeGenOptions::Embed_Marker) - .Default(~0U); - if (Model == ~0U) { - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; - Success = false; - } else - Opts.setEmbedBitcode( - static_cast<CodeGenOptions::EmbedBitcodeKind>(Model)); - } // FIXME: For backend options that are not yet recorded as function // attributes in the IR, keep track of them so we can embed them in a // separate data section and use them when building the bitcode. @@ -1272,15 +1065,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, } } - Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type); - Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions); - Opts.InstrumentFunctionsAfterInlining = - Args.hasArg(OPT_finstrument_functions_after_inlining); - Opts.InstrumentFunctionEntryBare = - Args.hasArg(OPT_finstrument_function_entry_bare); - - Opts.XRayInstructionThreshold = - getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags); Opts.XRayTotalFunctionGroups = getLastArgIntValue(Args, OPT_fxray_function_groups, 1, Diags); Opts.XRaySelectedFunctionGroup = @@ -1295,16 +1079,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, parseXRayInstrumentationBundle("-fxray-instrumentation-bundle=", A, Args, Diags, Opts.XRayInstrumentationBundle); - Opts.PatchableFunctionEntryCount = - getLastArgIntValue(Args, OPT_fpatchable_function_entry_EQ, 0, Diags); - Opts.PatchableFunctionEntryOffset = getLastArgIntValue( - Args, OPT_fpatchable_function_entry_offset_EQ, 0, Diags); - Opts.InstrumentForProfiling = Args.hasArg(OPT_pg); - Opts.CallFEntry = Args.hasArg(OPT_mfentry); - Opts.MNopMCount = Args.hasArg(OPT_mnop_mcount); - Opts.RecordMCount = Args.hasArg(OPT_mrecord_mcount); - Opts.PackedStack = Args.hasArg(OPT_mpacked_stack); - if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) { StringRef Name = A->getValue(); if (Name == "full") { @@ -1329,9 +1103,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Opts.setCompressDebugSections(DCT); } - Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations); - Opts.DebugCompilationDir = - std::string(Args.getLastArgValue(OPT_fdebug_compilation_dir)); for (auto *A : Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) { CodeGenOptions::BitcodeFileToLink F; @@ -1345,63 +1116,10 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, } Opts.LinkBitcodeFiles.push_back(F); } - Opts.SanitizeCoverageType = - getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags); - Opts.SanitizeCoverageIndirectCalls = - Args.hasArg(OPT_fsanitize_coverage_indirect_calls); - Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb); - Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp); - Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div); - Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep); - Opts.SanitizeCoverage8bitCounters = - Args.hasArg(OPT_fsanitize_coverage_8bit_counters); - Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc); - Opts.SanitizeCoverageTracePCGuard = - Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard); - Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune); - Opts.SanitizeCoverageInline8bitCounters = - Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters); - Opts.SanitizeCoverageInlineBoolFlag = - Args.hasArg(OPT_fsanitize_coverage_inline_bool_flag); - Opts.SanitizeCoveragePCTable = Args.hasArg(OPT_fsanitize_coverage_pc_table); - Opts.SanitizeCoverageStackDepth = - Args.hasArg(OPT_fsanitize_coverage_stack_depth); Opts.SanitizeCoverageAllowlistFiles = Args.getAllArgValues(OPT_fsanitize_coverage_allowlist); Opts.SanitizeCoverageBlocklistFiles = Args.getAllArgValues(OPT_fsanitize_coverage_blocklist); - Opts.SanitizeMemoryTrackOrigins = - getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags); - Opts.SanitizeMemoryUseAfterDtor = - Args.hasFlag(OPT_fsanitize_memory_use_after_dtor, - OPT_fno_sanitize_memory_use_after_dtor, - false); - Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime); - Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso); - Opts.SanitizeCfiICallGeneralizePointers = - Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers); - Opts.SanitizeCfiCanonicalJumpTables = - Args.hasArg(OPT_fsanitize_cfi_canonical_jump_tables); - Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats); - if (Arg *A = Args.getLastArg( - OPT_fsanitize_address_poison_custom_array_cookie, - OPT_fno_sanitize_address_poison_custom_array_cookie)) { - Opts.SanitizeAddressPoisonCustomArrayCookie = - A->getOption().getID() == - OPT_fsanitize_address_poison_custom_array_cookie; - } - if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope, - OPT_fno_sanitize_address_use_after_scope)) { - Opts.SanitizeAddressUseAfterScope = - A->getOption().getID() == OPT_fsanitize_address_use_after_scope; - } - Opts.SanitizeAddressGlobalsDeadStripping = - Args.hasArg(OPT_fsanitize_address_globals_dead_stripping); - if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_odr_indicator, - OPT_fno_sanitize_address_use_odr_indicator)) { - Opts.SanitizeAddressUseOdrIndicator = - A->getOption().getID() == OPT_fsanitize_address_use_odr_indicator; - } Opts.SSPBufferSize = getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags); @@ -1419,44 +1137,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, std::string(Args.getLastArgValue(OPT_mstack_protector_guard_reg_EQ, "none")); - Opts.StackRealignment = Args.hasArg(OPT_mstackrealign); - if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) { - StringRef Val = A->getValue(); - unsigned StackAlignment = Opts.StackAlignment; - Val.getAsInteger(10, StackAlignment); - Opts.StackAlignment = StackAlignment; - } - - if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) { - StringRef Val = A->getValue(); - unsigned StackProbeSize = Opts.StackProbeSize; - Val.getAsInteger(0, StackProbeSize); - Opts.StackProbeSize = StackProbeSize; - } - - Opts.NoStackArgProbe = Args.hasArg(OPT_mno_stack_arg_probe); - - Opts.StackClashProtector = Args.hasArg(OPT_fstack_clash_protection); - - if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) { - StringRef Name = A->getValue(); - unsigned Method = llvm::StringSwitch<unsigned>(Name) - .Case("legacy", CodeGenOptions::Legacy) - .Case("non-legacy", CodeGenOptions::NonLegacy) - .Case("mixed", CodeGenOptions::Mixed) - .Default(~0U); - if (Method == ~0U) { - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; - Success = false; - } else { - Opts.setObjCDispatchMethod( - static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method)); - } - } - - - if (Args.hasArg(OPT_fno_objc_convert_messages_to_runtime_calls)) - Opts.ObjCConvertMessagesToRuntimeCalls = 0; if (Args.getLastArg(OPT_femulated_tls) || Args.getLastArg(OPT_fno_emulated_tls)) { @@ -1465,24 +1145,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false); } - if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) { - StringRef Name = A->getValue(); - unsigned Model = llvm::StringSwitch<unsigned>(Name) - .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel) - .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel) - .Case("initial-exec", CodeGenOptions::InitialExecTLSModel) - .Case("local-exec", CodeGenOptions::LocalExecTLSModel) - .Default(~0U); - if (Model == ~0U) { - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; - Success = false; - } else { - Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model)); - } - } - - Opts.TLSSize = getLastArgIntValue(Args, OPT_mtls_size_EQ, 0, Diags); - if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) { StringRef Val = A->getValue(); Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val); @@ -1543,7 +1205,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option); bool NeedLocTracking = false; - Opts.OptRecordFile = std::string(Args.getLastArgValue(OPT_opt_record_file)); if (!Opts.OptRecordFile.empty()) NeedLocTracking = true; @@ -1575,8 +1236,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, NeedLocTracking = true; } - Opts.DiagnosticsWithHotness = - Args.hasArg(options::OPT_fdiagnostics_show_hotness); bool UsingSampleProfile = !Opts.SampleProfileFile.empty(); bool UsingProfile = UsingSampleProfile || (Opts.getProfileUse() != CodeGenOptions::ProfileNone); @@ -1628,35 +1287,12 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags, Opts.SanitizeTrap); - Opts.CudaGpuBinaryFileName = - std::string(Args.getLastArgValue(OPT_fcuda_include_gpubinary)); - - Opts.Backchain = Args.hasArg(OPT_mbackchain); - - Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue( - Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags); - Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true); - Opts.Addrsig = Args.hasArg(OPT_faddrsig); - - Opts.KeepStaticConsts = Args.hasArg(OPT_fkeep_static_consts); - - Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening); - Opts.DefaultFunctionAttrs = Args.getAllArgValues(OPT_default_function_attr); Opts.PassPlugins = Args.getAllArgValues(OPT_fpass_plugin_EQ); - Opts.SymbolPartition = - std::string(Args.getLastArgValue(OPT_fsymbol_partition_EQ)); - - Opts.ForceAAPCSBitfieldLoad = Args.hasArg(OPT_ForceAAPCSBitfieldLoad); - Opts.AAPCSBitfieldWidth = - Args.hasFlag(OPT_AAPCSBitfieldWidth, OPT_ForceNoAAPCSBitfieldWidth, true); - - Opts.PassByValueIsNoAlias = Args.hasArg(OPT_fpass_by_value_is_noalias); - return Success; } @@ -2089,7 +1725,6 @@ static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm); Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ); Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ); - Opts.ModuleMapFiles = Args.getAllArgValues(OPT_fmodule_map_file); // Only the -fmodule-file=<file> form. for (const auto *A : Args.filtered(OPT_fmodule_file)) { StringRef Val = A->getValue(); @@ -2618,9 +2253,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, } } - if (Args.hasArg(OPT_fno_dllexport_inlines)) - Opts.DllExportInlines = false; - if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) { StringRef Name = A->getValue(); if (Name == "full" || Name == "branch") { @@ -2649,7 +2281,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, LangStd = OpenCLLangStd; } - Opts.SYCL = Args.hasArg(options::OPT_fsycl); Opts.SYCLIsDevice = Opts.SYCL && Args.hasArg(options::OPT_fsycl_is_device); if (Opts.SYCL) { // -sycl-std applies to any SYCL source, not only those containing kernels, @@ -2669,9 +2300,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, } } - Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header); - Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins); - llvm::Triple T(TargetOpts.Triple); CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd); @@ -2698,25 +2326,9 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, if (Args.hasArg(OPT_fno_operator_names)) Opts.CXXOperatorNames = 0; - if (Args.hasArg(OPT_fcuda_is_device)) - Opts.CUDAIsDevice = 1; - - if (Args.hasArg(OPT_fcuda_allow_variadic_functions)) - Opts.CUDAAllowVariadicFunctions = 1; - - if (Args.hasArg(OPT_fno_cuda_host_device_constexpr)) - Opts.CUDAHostDeviceConstexpr = 0; - - if (Args.hasArg(OPT_fgpu_exclude_wrong_side_overloads)) - Opts.GPUExcludeWrongSideOverloads = 1; - - if (Args.hasArg(OPT_fgpu_defer_diag)) - Opts.GPUDeferDiag = 1; - if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals)) Opts.CUDADeviceApproxTranscendentals = 1; - Opts.GPURelocatableDeviceCode = Args.hasArg(OPT_fgpu_rdc); if (Args.hasArg(OPT_fgpu_allow_device_init)) { if (Opts.HIP) Opts.GPUAllowDeviceInit = 1; @@ -2724,7 +2336,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Diags.Report(diag::warn_ignored_hip_only_option) << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args); } - Opts.HIPUseNewLaunchAPI = Args.hasArg(OPT_fhip_new_launch_api); if (Opts.HIP) Opts.GPUMaxThreadsPerBlock = getLastArgIntValue( Args, OPT_gpu_max_threads_per_block_EQ, Opts.GPUMaxThreadsPerBlock); @@ -2774,9 +2385,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.ObjCWeak = Opts.ObjCWeakRuntime; } - if (Args.hasArg(OPT_fno_objc_infer_related_result_type)) - Opts.ObjCInferRelatedResultType = 0; - if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime)) Opts.ObjCSubscriptingLegacyRuntime = (Opts.ObjCRuntime.getKind() == ObjCRuntime::FragileMacOSX); @@ -2805,42 +2413,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.GNUInline = 1; } - if (Args.hasArg(OPT_fapple_kext)) { - if (!Opts.CPlusPlus) - Diags.Report(diag::warn_c_kext); - else - Opts.AppleKext = 1; - } - - if (Args.hasArg(OPT_print_ivar_layout)) - Opts.ObjCGCBitmapPrint = 1; - - if (Args.hasArg(OPT_fno_constant_cfstrings)) - Opts.NoConstantCFStrings = 1; - if (const auto *A = Args.getLastArg(OPT_fcf_runtime_abi_EQ)) - Opts.CFRuntime = - llvm::StringSwitch<LangOptions::CoreFoundationABI>(A->getValue()) - .Cases("unspecified", "standalone", "objc", - LangOptions::CoreFoundationABI::ObjectiveC) - .Cases("swift", "swift-5.0", - LangOptions::CoreFoundationABI::Swift5_0) - .Case("swift-4.2", LangOptions::CoreFoundationABI::Swift4_2) - .Case("swift-4.1", LangOptions::CoreFoundationABI::Swift4_1) - .Default(LangOptions::CoreFoundationABI::ObjectiveC); - - if (Args.hasArg(OPT_fzvector)) - Opts.ZVector = 1; - - if (Args.hasArg(OPT_pthread)) - Opts.POSIXThreads = 1; - - // The value-visibility mode defaults to "default". - if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) { - Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags)); - } else { - Opts.setValueVisibilityMode(DefaultVisibility); - } - // The type-visibility mode defaults to the value-visibility mode. if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) { Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags)); @@ -2848,18 +2420,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode()); } - if (Args.hasArg(OPT_fvisibility_inlines_hidden)) - Opts.InlineVisibilityHidden = 1; - - if (Args.hasArg(OPT_fvisibility_inlines_hidden_static_local_var)) - Opts.VisibilityInlinesHiddenStaticLocalVar = 1; - - if (Args.hasArg(OPT_fvisibility_global_new_delete_hidden)) - Opts.GlobalAllocationFunctionVisibilityHidden = 1; - - if (Args.hasArg(OPT_fapply_global_visibility_to_externs)) - Opts.SetVisibilityForExternDecls = 1; - if (Args.hasArg(OPT_fvisibility_from_dllstorageclass)) { Opts.VisibilityFromDLLStorageClass = 1; @@ -2901,7 +2461,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, else if (Args.hasArg(OPT_fwrapv)) Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined); - Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility); Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions); Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt; Opts.MSCompatibilityVersion = 0; @@ -2927,31 +2486,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, OPT_fno_dollars_in_identifiers, Opts.DollarIdents); - Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings); - Opts.setVtorDispMode( - MSVtorDispMode(getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags))); - Opts.Borland = Args.hasArg(OPT_fborland_extensions); - Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings); - Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings, - Opts.ConstStrings); - if (Arg *A = Args.getLastArg(OPT_flax_vector_conversions_EQ)) { - using LaxKind = LangOptions::LaxVectorConversionKind; - if (auto Kind = llvm::StringSwitch<Optional<LaxKind>>(A->getValue()) - .Case("none", LaxKind::None) - .Case("integer", LaxKind::Integer) - .Case("all", LaxKind::All) - .Default(llvm::None)) - Opts.setLaxVectorConversions(*Kind); - else - Diags.Report(diag::err_drv_invalid_value) - << A->getAsString(Args) << A->getValue(); - } - if (Args.hasArg(OPT_fno_threadsafe_statics)) - Opts.ThreadsafeStatics = 0; - Opts.Exceptions = Args.hasArg(OPT_fexceptions); - Opts.IgnoreExceptions = Args.hasArg(OPT_fignore_exceptions); - Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions); - Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions); // -ffixed-point Opts.FixedPoint = @@ -2963,14 +2497,10 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, /*Default=*/false) && Opts.FixedPoint; - Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind); - Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp); - Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti); Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data); Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL && Opts.OpenCLVersion == 200); - Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional); Opts.Coroutines = Opts.CPlusPlus20 || Args.hasArg(OPT_fcoroutines_ts); Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || @@ -2983,10 +2513,8 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.DoubleSquareBracketAttributes); Opts.CPlusPlusModules = Opts.CPlusPlus20; - Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts); Opts.Modules = Args.hasArg(OPT_fmodules) || Opts.ModulesTS || Opts.CPlusPlusModules; - Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse); Opts.ModulesDeclUse = Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse; // FIXME: We only need this in C++ modules / Modules TS if we might textually @@ -2994,113 +2522,32 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.ModulesLocalVisibility = Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS || Opts.CPlusPlusModules; - Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen); - Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo); Opts.ModulesSearchAll = Opts.Modules && !Args.hasArg(OPT_fno_modules_search_all) && Args.hasArg(OPT_fmodules_search_all); - Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery); - Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules); Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char); Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar); Opts.Char8 = Args.hasFlag(OPT_fchar8__t, OPT_fno_char8__t, Opts.CPlusPlus20); - if (const Arg *A = Args.getLastArg(OPT_fwchar_type_EQ)) { - Opts.WCharSize = llvm::StringSwitch<unsigned>(A->getValue()) - .Case("char", 1) - .Case("short", 2) - .Case("int", 4) - .Default(0); - if (Opts.WCharSize == 0) - Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue(); - } - Opts.WCharIsSigned = Args.hasFlag(OPT_fsigned_wchar, OPT_fno_signed_wchar, true); - Opts.ShortEnums = Args.hasArg(OPT_fshort_enums); - Opts.Freestanding = Args.hasArg(OPT_ffreestanding); Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; if (!Opts.NoBuiltin) getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs); - Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin); - Opts.RelaxedTemplateTemplateArgs = - Args.hasArg(OPT_frelaxed_template_template_args); - Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation); Opts.AlignedAllocation = Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation, Opts.AlignedAllocation); Opts.AlignedAllocationUnavailable = Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable); - Opts.NewAlignOverride = - getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags); - if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) { - Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ); - Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args) - << A->getValue(); - Opts.NewAlignOverride = 0; - } - Opts.ConceptSatisfactionCaching = - !Args.hasArg(OPT_fno_concept_satisfaction_caching); if (Args.hasArg(OPT_fconcepts_ts)) Diags.Report(diag::warn_fe_concepts_ts_flag); - Opts.RecoveryAST = Args.hasFlag(OPT_frecovery_ast, OPT_fno_recovery_ast); - Opts.RecoveryASTType = - Args.hasFlag(OPT_frecovery_ast_type, OPT_fno_recovery_ast_type); - Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions); - Opts.AccessControl = !Args.hasArg(OPT_fno_access_control); - Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors); Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno); - Opts.InstantiationDepth = - getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags); - Opts.ArrowDepth = - getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags); - Opts.ConstexprCallDepth = - getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags); - Opts.ConstexprStepLimit = - getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags); - Opts.EnableNewConstInterp = - Args.hasArg(OPT_fexperimental_new_constant_interpreter); - Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags); - Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing); - Opts.NumLargeByValueCopy = - getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags); - Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields); - Opts.ObjCConstantStringClass = - std::string(Args.getLastArgValue(OPT_fconstant_string_class)); - Opts.ObjCDefaultSynthProperties = - !Args.hasArg(OPT_disable_objc_default_synthesize_properties); - Opts.EncodeExtendedBlockSig = - Args.hasArg(OPT_fencode_extended_block_signature); - Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls); - Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags); - Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags); - Opts.AlignDouble = Args.hasArg(OPT_malign_double); - Opts.DoubleSize = getLastArgIntValue(Args, OPT_mdouble_EQ, 0, Diags); Opts.LongDoubleSize = Args.hasArg(OPT_mlong_double_128) ? 128 : Args.hasArg(OPT_mlong_double_64) ? 64 : 0; - Opts.PPCIEEELongDouble = Args.hasArg(OPT_mabi_EQ_ieeelongdouble); Opts.EnableAIXExtendedAltivecABI = Args.hasArg(OPT_mabi_EQ_vec_extabi); Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); - Opts.ROPI = Args.hasArg(OPT_fropi); - Opts.RWPI = Args.hasArg(OPT_frwpi); - Opts.PIE = Args.hasArg(OPT_pic_is_pie); - Opts.Static = Args.hasArg(OPT_static_define); - Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple); Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple || Args.hasArg(OPT_fdump_record_layouts); - Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts); - Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking); - Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align); if (Opts.FastRelaxedMath) Opts.setDefaultFPContractMode(LangOptions::FPM_Fast); - Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat); - Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map); - Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype); - Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support); - Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id); - Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal); - Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack); - Opts.ModuleName = std::string(Args.getLastArgValue(OPT_fmodule_name_EQ)); - Opts.CurrentModule = Opts.ModuleName; - Opts.AppExt = Args.hasArg(OPT_fapplication_extension); Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature); llvm::sort(Opts.ModuleFeatures); Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type); @@ -3109,8 +2556,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, // is enabled. Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns) | Opts.NativeHalfArgsAndReturns; - Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm); - Opts.Cmse = Args.hasArg(OPT_mcmse); // Armv8-M Security Extensions Opts.ArmSveVectorBits = getLastArgIntValue(Args, options::OPT_msve_vector_bits_EQ, 0, Diags); @@ -3127,79 +2572,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec, (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA)); - if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) { - switch (llvm::StringSwitch<unsigned>(A->getValue()) - .Case("target", LangOptions::ASMM_Target) - .Case("no", LangOptions::ASMM_Off) - .Case("yes", LangOptions::ASMM_On) - .Default(255)) { - default: - Diags.Report(diag::err_drv_invalid_value) - << "-faddress-space-map-mangling=" << A->getValue(); - break; - case LangOptions::ASMM_Target: - Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Target); - break; - case LangOptions::ASMM_On: - Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On); - break; - case LangOptions::ASMM_Off: - Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off); - break; - } - } - - if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) { - LangOptions::PragmaMSPointersToMembersKind InheritanceModel = - llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>( - A->getValue()) - .Case("single", - LangOptions::PPTMK_FullGeneralitySingleInheritance) - .Case("multiple", - LangOptions::PPTMK_FullGeneralityMultipleInheritance) - .Case("virtual", - LangOptions::PPTMK_FullGeneralityVirtualInheritance) - .Default(LangOptions::PPTMK_BestCase); - if (InheritanceModel == LangOptions::PPTMK_BestCase) - Diags.Report(diag::err_drv_invalid_value) - << "-fms-memptr-rep=" << A->getValue(); - - Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel); - } - - // Check for MS default calling conventions being specified. - if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) { - LangOptions::DefaultCallingConvention DefaultCC = - llvm::StringSwitch<LangOptions::DefaultCallingConvention>(A->getValue()) - .Case("cdecl", LangOptions::DCC_CDecl) - .Case("fastcall", LangOptions::DCC_FastCall) - .Case("stdcall", LangOptions::DCC_StdCall) - .Case("vectorcall", LangOptions::DCC_VectorCall) - .Case("regcall", LangOptions::DCC_RegCall) - .Default(LangOptions::DCC_None); - if (DefaultCC == LangOptions::DCC_None) - Diags.Report(diag::err_drv_invalid_value) - << "-fdefault-calling-conv=" << A->getValue(); - - llvm::Triple T(TargetOpts.Triple); - llvm::Triple::ArchType Arch = T.getArch(); - bool emitError = (DefaultCC == LangOptions::DCC_FastCall || - DefaultCC == LangOptions::DCC_StdCall) && - Arch != llvm::Triple::x86; - emitError |= (DefaultCC == LangOptions::DCC_VectorCall || - DefaultCC == LangOptions::DCC_RegCall) && - !T.isX86(); - if (emitError) - Diags.Report(diag::err_drv_argument_not_allowed_with) - << A->getSpelling() << T.getTriple(); - else - Opts.setDefaultCallingConv(DefaultCC); - } - - Opts.SemanticInterposition = Args.hasArg(OPT_fsemantic_interposition); - Opts.HalfNoSemanticInterposition = - Args.hasArg(OPT_fhalf_no_semantic_interposition); - // -mrtd option if (Arg *A = Args.getLastArg(OPT_mrtd)) { if (Opts.getDefaultCallingConv() != LangOptions::DCC_None) @@ -3215,8 +2587,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, } } - // Check if -fopenmp is specified and set default version to 5.0. - Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 50 : 0; // Check if -fopenmp-simd is specified. bool IsSimdSpecified = Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd, @@ -3271,11 +2641,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Opts.OpenMPCUDAReductionBufNum, Diags); } - // Prevent auto-widening the representation of loop counters during an - // OpenMP collapse clause. - Opts.OpenMPOptimisticCollapse = - Args.hasArg(options::OPT_fopenmp_optimistic_collapse) ? 1 : 0; - // Get the OpenMP target triples if any. if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) { enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit }; @@ -3366,12 +2731,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val; } - auto FPRM = llvm::RoundingMode::NearestTiesToEven; - if (Args.hasArg(OPT_frounding_math)) { - FPRM = llvm::RoundingMode::Dynamic; - } - Opts.setFPRoundingMode(FPRM); - if (Args.hasArg(OPT_ftrapping_math)) { Opts.setFPExceptionMode(LangOptions::FPE_Strict); } @@ -3394,45 +2753,9 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, } Opts.setFPExceptionMode(FPEB); - Opts.RetainCommentsFromSystemHeaders = - Args.hasArg(OPT_fretain_comments_from_system_headers); - - unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags); - switch (SSP) { - default: - Diags.Report(diag::err_drv_invalid_value) - << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP; - break; - case 0: Opts.setStackProtector(LangOptions::SSPOff); break; - case 1: Opts.setStackProtector(LangOptions::SSPOn); break; - case 2: Opts.setStackProtector(LangOptions::SSPStrong); break; - case 3: Opts.setStackProtector(LangOptions::SSPReq); break; - } - - if (Arg *A = Args.getLastArg(OPT_ftrivial_auto_var_init)) { - StringRef Val = A->getValue(); - if (Val == "uninitialized") - Opts.setTrivialAutoVarInit( - LangOptions::TrivialAutoVarInitKind::Uninitialized); - else if (Val == "zero") - Opts.setTrivialAutoVarInit(LangOptions::TrivialAutoVarInitKind::Zero); - else if (Val == "pattern") - Opts.setTrivialAutoVarInit(LangOptions::TrivialAutoVarInitKind::Pattern); - else - Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val; - } - - if (Arg *A = Args.getLastArg(OPT_ftrivial_auto_var_init_stop_after)) { - int Val = std::stoi(A->getValue()); - Opts.TrivialAutoVarInitStopAfter = Val; - } - // Parse -fsanitize= arguments. parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ), Diags, Opts.Sanitize); - // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here. - Opts.SanitizeAddressFieldPadding = - getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags); Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist); std::vector<std::string> systemBlacklists = Args.getAllArgValues(OPT_fsanitize_system_blacklist); @@ -3447,14 +2770,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, Args.getAllArgValues(OPT_fxray_never_instrument); Opts.XRayAttrListFiles = Args.getAllArgValues(OPT_fxray_attr_list); - // -fforce-emit-vtables - Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables); - - // -fallow-editor-placeholders - Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders); - - Opts.RegisterStaticDestructors = !Args.hasArg(OPT_fno_cxx_static_destructors); - if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) { Opts.setClangABICompat(LangOptions::ClangABI::Latest); @@ -3490,14 +2805,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, } } - Opts.CompleteMemberPointers = Args.hasArg(OPT_fcomplete_member_pointers); - Opts.BuildingPCHWithObjectFile = Args.hasArg(OPT_building_pch_with_obj); - Opts.PCHInstantiateTemplates = Args.hasArg(OPT_fpch_instantiate_templates); - - Opts.MatrixTypes = Args.hasArg(OPT_fenable_matrix); - - Opts.MaxTokens = getLastArgIntValue(Args, OPT_fmax_tokens_EQ, 0, Diags); - if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) { StringRef SignScope = A->getValue(); @@ -3530,17 +2837,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, } } - Opts.BranchTargetEnforcement = Args.hasArg(OPT_mbranch_target_enforce); - Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening); - - Opts.CompatibilityQualifiedIdBlockParamTypeChecking = - Args.hasArg(OPT_fcompatibility_qualified_id_block_param_type_checking); - - Opts.RelativeCXXABIVTables = - Args.hasFlag(OPT_fexperimental_relative_cxx_abi_vtables, - OPT_fno_experimental_relative_cxx_abi_vtables, - /*default=*/false); - std::string ThreadModel = std::string(Args.getLastArgValue(OPT_mthread_model, "posix")); if (ThreadModel != "posix" && ThreadModel != "single") @@ -3788,7 +3084,6 @@ bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, // PIClevel and PIELevel are needed during code generation and this should be // set regardless of the input type. LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); - LangOpts.PIE = Args.hasArg(OPT_pic_is_pie); parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ), Diags, LangOpts.Sanitize); } else { @@ -3806,9 +3101,6 @@ bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, } } - LangOpts.FunctionAlignment = - getLastArgIntValue(Args, OPT_function_alignment, 0, Diags); - if (LangOpts.CUDA) { // During CUDA device-side compilation, the aux triple is the // triple used for host compilation. @@ -3849,7 +3141,7 @@ bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, Res.getCodeGenOpts().Argv0 = Argv0; Res.getCodeGenOpts().CommandLineArgs = CommandLineArgs; - FixupInvocation(Res, Diags); + FixupInvocation(Res, Diags, Args); return Success; } @@ -3982,7 +3274,8 @@ void CompilerInvocation::generateCC1CommandLine( (Extracted != \ static_cast<decltype(this->KEYPATH)>( \ (IMPLIED_CHECK) ? (IMPLIED_VALUE) : (DEFAULT_VALUE)))) \ - DENORMALIZER(Args, SPELLING, SA, TABLE_INDEX, Extracted); \ + DENORMALIZER(Args, SPELLING, SA, Option::KIND##Class, TABLE_INDEX, \ + Extracted); \ }(EXTRACTOR(this->KEYPATH)); \ } diff --git a/clang/test/Profile/c-generate.c b/clang/test/Profile/c-generate.c index 1e7a739..70ab757 100644 --- a/clang/test/Profile/c-generate.c +++ b/clang/test/Profile/c-generate.c @@ -7,7 +7,7 @@ // // PROF-INSTR-NONE-NOT: __llvm_prf // -// PROF-INSTR-GARBAGE: invalid PGO instrumentor in argument '-fprofile-instrument=garbage' +// PROF-INSTR-GARBAGE: invalid value 'garbage' in '-fprofile-instrument=garbage' int main(void) { return 0; diff --git a/clang/unittests/Frontend/CompilerInvocationTest.cpp b/clang/unittests/Frontend/CompilerInvocationTest.cpp index 83ae169..8960e26 100644 --- a/clang/unittests/Frontend/CompilerInvocationTest.cpp +++ b/clang/unittests/Frontend/CompilerInvocationTest.cpp @@ -18,6 +18,7 @@ using namespace llvm; using namespace clang; using ::testing::Contains; +using ::testing::HasSubstr; using ::testing::StrEq; namespace { @@ -342,30 +343,109 @@ TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) { ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str()))); } -TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateEnumNonDefault) { +TEST_F(CommandLineTest, SeparateEnumNonDefault) { const char *Args[] = {"-mrelocation-model", "static"}; CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_FALSE(Diags->hasErrorOccurred()); + ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::Static); Invocation.generateCC1CommandLine(GeneratedArgs, *this); // Non default relocation model. + ASSERT_THAT(GeneratedArgs, Contains(StrEq("-mrelocation-model"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("static"))); + ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=static")))); } -TEST_F(CommandLineTest, CanGenerateCC1COmmandLineSeparateEnumDefault) { +TEST_F(CommandLineTest, SeparateEnumDefault) { const char *Args[] = {"-mrelocation-model", "pic"}; CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_FALSE(Diags->hasErrorOccurred()); + ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::PIC_); Invocation.generateCC1CommandLine(GeneratedArgs, *this); // Default relocation model. + ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("pic")))); + ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=pic")))); +} + +TEST_F(CommandLineTest, JoinedEnumNonDefault) { + const char *Args[] = {"-fobjc-dispatch-method=non-legacy"}; + + CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); + + ASSERT_FALSE(Diags->hasErrorOccurred()); + ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(), + CodeGenOptions::NonLegacy); + + Invocation.generateCC1CommandLine(GeneratedArgs, *this); + + ASSERT_THAT(GeneratedArgs, + Contains(StrEq("-fobjc-dispatch-method=non-legacy"))); + ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method=")))); + ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("non-legacy")))); +} + +TEST_F(CommandLineTest, JoinedEnumDefault) { + const char *Args[] = {"-fobjc-dispatch-method=legacy"}; + + CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); + + ASSERT_FALSE(Diags->hasErrorOccurred()); + ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(), + CodeGenOptions::Legacy); + + Invocation.generateCC1CommandLine(GeneratedArgs, *this); + + ASSERT_THAT(GeneratedArgs, + Not(Contains(StrEq("-fobjc-dispatch-method=legacy")))); + ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method=")))); + ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("legacy")))); +} + +TEST_F(CommandLineTest, StringVectorEmpty) { + const char *Args[] = {""}; + + CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); + + ASSERT_FALSE(Diags->hasErrorOccurred()); + ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles.empty()); + + Invocation.generateCC1CommandLine(GeneratedArgs, *this); + ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-fmodule-map-file=")))); +} + +TEST_F(CommandLineTest, StringVectorSingle) { + const char *Args[] = {"-fmodule-map-file=a"}; + + CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); + + ASSERT_FALSE(Diags->hasErrorOccurred()); + ASSERT_EQ(Invocation.getFrontendOpts().ModuleMapFiles, + std::vector<std::string>({"a"})); + + Invocation.generateCC1CommandLine(GeneratedArgs, *this); + ASSERT_EQ(count(GeneratedArgs, StringRef("-fmodule-map-file=a")), 1); +} + +TEST_F(CommandLineTest, StringVectorMultiple) { + const char *Args[] = {"-fmodule-map-file=a", "-fmodule-map-file=b"}; + + CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); + + ASSERT_FALSE(Diags->hasErrorOccurred()); + ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles == + std::vector<std::string>({"a", "b"})); + + Invocation.generateCC1CommandLine(GeneratedArgs, *this); + ASSERT_EQ(count(GeneratedArgs, StringRef("-fmodule-map-file=a")), 1); + ASSERT_EQ(count(GeneratedArgs, StringRef("-fmodule-map-file=b")), 1); } // Wide integer option. diff --git a/llvm/include/llvm/Option/OptParser.td b/llvm/include/llvm/Option/OptParser.td index c123329..e1139d6 100644 --- a/llvm/include/llvm/Option/OptParser.td +++ b/llvm/include/llvm/Option/OptParser.td @@ -167,12 +167,24 @@ class MarshallingInfoStringInt<code keypath, code defaultvalue="0", code type="u code Denormalizer = "denormalizeString"; } +class MarshallingInfoStringVector<code keypath> + : MarshallingInfo<keypath, "std::vector<std::string>({})"> { + code Normalizer = "normalizeStringVector"; + code Denormalizer = "denormalizeStringVector"; +} + class MarshallingInfoFlag<code keypath, code defaultvalue = "false"> : MarshallingInfo<keypath, defaultvalue> { code Normalizer = "normalizeSimpleFlag"; code Denormalizer = "denormalizeSimpleFlag"; } +class MarshallingInfoNegativeFlag<code keypath, code defaultvalue = "true"> + : MarshallingInfo<keypath, defaultvalue> { + code Normalizer = "normalizeSimpleNegativeFlag"; + code Denormalizer = "denormalizeSimpleFlag"; +} + class MarshallingInfoBitfieldFlag<code keypath, code value> : MarshallingInfoFlag<keypath, "0u"> { code Normalizer = "makeFlagToValueNormalizer("#value#")"; @@ -190,9 +202,6 @@ class MarshallingInfoBooleanFlag<code keypath, code defaultvalue, code value, co // Mixins for additional marshalling attributes. -class IsNegative { - code Normalizer = "normalizeSimpleNegativeFlag"; -} class AlwaysEmit { bit ShouldAlwaysEmit = true; } class Normalizer<code normalizer> { code Normalizer = normalizer; } class Denormalizer<code denormalizer> { code Denormalizer = denormalizer; } @@ -202,9 +211,6 @@ class AutoNormalizeEnum { code Normalizer = "normalizeSimpleEnum"; code Denormalizer = "denormalizeSimpleEnum"; } -class AutoNormalizeEnumJoined : AutoNormalizeEnum { - code Denormalizer = "denormalizeSimpleEnumJoined"; -} class ValueMerger<code merger> { code ValueMerger = merger; } class ValueExtractor<code extractor> { code ValueExtractor = extractor; } |