diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -233,7 +233,7 @@ string help="", list flags=[], code keypath=""> { def f#NAME : Flag<["-"], "f"#name>, Flags, Group, HelpText, - MarshallingInfoFlag; + MarshallingInfoFlag; def fno_#NAME : Flag<["-"], "fno-"#name>, Flags, Group, HelpText; } @@ -246,7 +246,7 @@ Group, HelpText; def fno_#NAME : Flag<["-"], "fno-"#name>, Flags, Group, HelpText, - MarshallingInfoFlag; + MarshallingInfoFlag; } multiclass BooleanMarshalledFFlag { @@ -331,7 +331,7 @@ // Comment Options def fparse_all_comments : Flag<["-"], "fparse-all-comments">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->CommentOpts.ParseAllComments", "false">; + MarshallingInfoFlag<"LangOpts->CommentOpts.ParseAllComments">; // Filesystem Options FileSystemOpts @@ -345,17 +345,18 @@ def MV : Flag<["-"], "MV">, Group, Flags<[CC1Option]>, HelpText<"Use NMake/Jom format for the depfile">, - MarshallingInfoFlag<"DependencyOutputOpts.OutputFormat", "DependencyOutputFormat::Make">, + MarshallingInfoFlag<"DependencyOutputOpts.OutputFormat">, + DefaultValue<"DependencyOutputFormat::Make">, Normalizer<"(normalizeFlagToValue)">; def H : Flag<["-"], "H">, Flags<[CC1Option]>, Group, HelpText<"Show header includes and nesting depth">, - MarshallingInfoFlag<"DependencyOutputOpts.ShowHeaderIncludes", "false">; + MarshallingInfoFlag<"DependencyOutputOpts.ShowHeaderIncludes">; def MG : Flag<["-"], "MG">, Group, Flags<[CC1Option]>, HelpText<"Add missing headers to depfile">, - MarshallingInfoFlag<"DependencyOutputOpts.AddMissingHeaderDeps", "false">; + MarshallingInfoFlag<"DependencyOutputOpts.AddMissingHeaderDeps">; def MP : Flag<["-"], "MP">, Group, Flags<[CC1Option]>, HelpText<"Create phony target for each dependency (other than main file)">, - MarshallingInfoFlag<"DependencyOutputOpts.UsePhonyTargets", "false">; + MarshallingInfoFlag<"DependencyOutputOpts.UsePhonyTargets">; def dependency_file : Separate<["-"], "dependency-file">, Flags<[CC1Option]>, HelpText<"Filename (or -) to write dependency output to">, @@ -371,10 +372,10 @@ def sys_header_deps : Flag<["-"], "sys-header-deps">, HelpText<"Include system headers in dependency output">, - MarshallingInfoFlag<"DependencyOutputOpts.IncludeSystemHeaders", "false">; + MarshallingInfoFlag<"DependencyOutputOpts.IncludeSystemHeaders">; def module_file_deps : Flag<["-"], "module-file-deps">, HelpText<"Include module files in dependency output">, - MarshallingInfoFlag<"DependencyOutputOpts.IncludeModuleFiles", "false">; + MarshallingInfoFlag<"DependencyOutputOpts.IncludeModuleFiles">; def header_include_file : Separate<["-"], "header-include-file">, HelpText<"Filename (or -) to write header include output to">, @@ -388,49 +389,49 @@ def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits">, Group, Flags<[CoreOption, CC1Option]>, HelpText<"Print fix-its in machine parseable form">, - MarshallingInfoFlag<"ShowParseableFixits", "false">; + MarshallingInfoFlag<"ShowParseableFixits">; def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group, Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">, - MarshallingInfoFlag<"UseANSIEscapeCodes", "false">; + MarshallingInfoFlag<"UseANSIEscapeCodes">; def fdiagnostics_print_source_range_info : Flag<["-"], "fdiagnostics-print-source-range-info">, Group, Flags<[CC1Option]>, HelpText<"Print source range spans in numeric form">, - MarshallingInfoFlag<"ShowSourceRanges", "false">; + MarshallingInfoFlag<"ShowSourceRanges">; def fdiagnostics_show_template_tree : Flag<["-"], "fdiagnostics-show-template-tree">, Group, Flags<[CC1Option]>, HelpText<"Print a template comparison tree for differing templates">, - MarshallingInfoFlag<"ShowTemplateTree", "false">; + MarshallingInfoFlag<"ShowTemplateTree">; def fno_elide_type : Flag<["-"], "fno-elide-type">, Group, Flags<[CC1Option]>, HelpText<"Do not elide types when printing diagnostics">, - MarshallingInfoFlag<"ElideType", "true">, IsNegative; + MarshallingInfoNegativeFlag<"ElideType">; def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group, Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">, - MarshallingInfoFlag<"AbsolutePath", "false">; + MarshallingInfoFlag<"AbsolutePath">; def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"PedanticErrors", "false">; + MarshallingInfoFlag<"PedanticErrors">; def pedantic : Flag<["-", "--"], "pedantic">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"Pedantic", "false">; + MarshallingInfoFlag<"Pedantic">; def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>, - MarshallingInfoFlag<"IgnoreWarnings", "false">; + MarshallingInfoFlag<"IgnoreWarnings">; def fcaret_diagnostics : Flag<["-"], "fcaret-diagnostics">, Group; def fno_caret_diagnostics : Flag<["-"], "fno-caret-diagnostics">, Flags<[CC1Option]>, - Group, MarshallingInfoFlag<"ShowCarets", "true">, IsNegative; + Group, MarshallingInfoNegativeFlag<"ShowCarets">; def fshow_column : Flag<["-"], "fshow-column">, Group; def fno_show_column : Flag<["-"], "fno-show-column">, Flags<[CC1Option]>, Group, HelpText<"Do not include column number on diagnostics">, - MarshallingInfoFlag<"ShowColumn", "true">, IsNegative; + MarshallingInfoNegativeFlag<"ShowColumn">; def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group, Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">, - MarshallingInfoFlag<"ShowFixits", "true">, IsNegative; + MarshallingInfoNegativeFlag<"ShowFixits">; def fshow_source_location : Flag<["-"], "fshow-source-location">, Group; def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group, Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">, - MarshallingInfoFlag<"ShowLocation", "true">, IsNegative; + MarshallingInfoNegativeFlag<"ShowLocation">; def fdiagnostics_show_option : Flag<["-"], "fdiagnostics-show-option">, Group, HelpText<"Print option name with mappable diagnostics">; def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"ShowOptionNames", "true">, IsNegative; + MarshallingInfoNegativeFlag<"ShowOptionNames">; defm diagnostics_show_note_include_stack : BooleanMarshalledFFlag<"diagnostics-show-note-include-stack", "ShowNoteIncludeStack", "false", "Display include stacks for diagnostic notes">, Group, Flags<[CC1Option]>; @@ -448,10 +449,10 @@ def fno_diagnostics_use_presumed_location : Flag<["-"], "fno-diagnostics-use-presumed-location">, HelpText<"Ignore #line directives when displaying diagnostic locations">, - MarshallingInfoFlag<"ShowPresumedLoc", "true">, IsNegative; + MarshallingInfoNegativeFlag<"ShowPresumedLoc">; def Wno_rewrite_macros : Flag<["-"], "Wno-rewrite-macros">, HelpText<"Silence ObjC rewriting warnings">, - MarshallingInfoFlag<"NoRewriteMacros", "false">; + MarshallingInfoFlag<"NoRewriteMacros">; def diagnostic_log_file : Separate<["-"], "diagnostic-log-file">, HelpText<"Filename (or -) to log diagnostics to">, @@ -500,7 +501,7 @@ def arcmt_migrate_emit_arc_errors : Flag<["-"], "arcmt-migrate-emit-errors">, HelpText<"Emit ARC errors even if the migrator can fix them">, Flags<[CC1Option]>, - MarshallingInfoFlag<"FrontendOpts.ARCMTMigrateEmitARCErrors", "false">; + MarshallingInfoFlag<"FrontendOpts.ARCMTMigrateEmitARCErrors">; def objcmt_migrate_literals : Flag<["-"], "objcmt-migrate-literals">, Flags<[CC1Option]>, HelpText<"Enable migration to modern ObjC literals">, MarshallingInfoBitfieldFlag<"FrontendOpts.ObjCMTAction", "FrontendOptions::ObjCMT_Literals">; @@ -548,13 +549,13 @@ MarshallingInfoBitfieldFlag<"FrontendOpts.ObjCMTAction", "FrontendOptions::ObjCMT_DesignatedInitializer">; def fsystem_module : Flag<["-"], "fsystem-module">, Flags<[CC1Option]>, HelpText<"Build this module as a system module. Only used with -emit-module">, - MarshallingInfoFlag<"FrontendOpts.IsSystemModule", "false">; + MarshallingInfoFlag<"FrontendOpts.IsSystemModule">; def fno_temp_file : Flag<["-"], "fno-temp-file">, 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; + MarshallingInfoNegativeFlag<"FrontendOpts.UseTemporary">; def ftime_report : Flag<["-"], "ftime-report">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"FrontendOpts.ShowTimers", "false">; + MarshallingInfoFlag<"FrontendOpts.ShowTimers">; def ftime_trace : Flag<["-"], "ftime-trace">, Group, HelpText<"Turn on time profiler. Generates JSON file based on output filename.">, DocBrief<[{ @@ -562,18 +563,18 @@ can be analyzed with chrome://tracing or `Speedscope App `_ for flamegraph visualization.}]>, Flags<[CC1Option, CoreOption]>, - MarshallingInfoFlag<"FrontendOpts.TimeTrace", "false">; + MarshallingInfoFlag<"FrontendOpts.TimeTrace">; def help : Flag<["-", "--"], "help">, Flags<[CC1Option,CC1AsOption]>, HelpText<"Display available options">, - MarshallingInfoFlag<"FrontendOpts.ShowHelp", "false">; + MarshallingInfoFlag<"FrontendOpts.ShowHelp">; def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, Flags<[CC1Option]>, HelpText<"Whether to build a relocatable precompiled header">, - MarshallingInfoFlag<"FrontendOpts.RelocatablePCH", "false">; + MarshallingInfoFlag<"FrontendOpts.RelocatablePCH">; def print_supported_cpus : Flag<["-", "--"], "print-supported-cpus">, Group, Flags<[CC1Option, CoreOption]>, HelpText<"Print supported cpu models for the given target (if target is not specified," " it will print the supported cpus for the default target)">, - MarshallingInfoFlag<"FrontendOpts.PrintSupportedCPUs", "false">; + MarshallingInfoFlag<"FrontendOpts.PrintSupportedCPUs">; def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>, HelpText<"Write output to ">, MetaVarName<"">, @@ -596,40 +597,40 @@ def code_completion_macros : Flag<["-"], "code-completion-macros">, HelpText<"Include macros in code-completion results">, - MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeMacros", "false">; + MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeMacros">; def code_completion_patterns : Flag<["-"], "code-completion-patterns">, HelpText<"Include code patterns in code-completion results">, - MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeCodePatterns", "false">; + 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", "false">; + MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeBriefComments">; def code_completion_with_fixits : Flag<["-"], "code-completion-with-fixits">, HelpText<"Include code completion results which require small fix-its.">, - MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeFixIts", "false">; + MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeFixIts">; def disable_free : Flag<["-"], "disable-free">, HelpText<"Disable freeing of memory on exit">, - MarshallingInfoFlag<"FrontendOpts.DisableFree", "false">; + MarshallingInfoFlag<"FrontendOpts.DisableFree">; 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 fmodules_embed_all_files : Joined<["-"], "fmodules-embed-all-files">, HelpText<"Embed the contents of all files read by this compilation into " "the produced module file.">, - MarshallingInfoFlag<"FrontendOpts.ModulesEmbedAllFiles", "false">; + MarshallingInfoFlag<"FrontendOpts.ModulesEmbedAllFiles">; def ast_dump_decl_types : Flag<["-"], "ast-dump-decl-types">, Group, HelpText<"Include declaration types in AST dumps">, - MarshallingInfoFlag<"FrontendOpts.ASTDumpDeclTypes", "false">; + MarshallingInfoFlag<"FrontendOpts.ASTDumpDeclTypes">; def ast_dump_lookups : Flag<["-"], "ast-dump-lookups">, Group, HelpText<"Build ASTs and then debug dump their name lookup tables">, - MarshallingInfoFlag<"FrontendOpts.ASTDumpLookups", "false">; + MarshallingInfoFlag<"FrontendOpts.ASTDumpLookups">; def arcmt_action_EQ : Joined<["-"], "arcmt-action=">, Flags<[CC1Option, NoDriverOption]>, HelpText<"The ARC migration action to take">, Values<"check,modify,migrate">, NormalizedValuesScope<"FrontendOptions">, @@ -638,22 +639,22 @@ AutoNormalizeEnum; def print_stats : Flag<["-"], "print-stats">, HelpText<"Print performance metrics and statistics">, - MarshallingInfoFlag<"FrontendOpts.ShowStats", "false">; + MarshallingInfoFlag<"FrontendOpts.ShowStats">; 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", "false">; + MarshallingInfoFlag<"FrontendOpts.FixWhatYouCan">; def fix_only_warnings : Flag<["-"], "fix-only-warnings">, HelpText<"Apply fix-it advice only for warnings, not errors">, - MarshallingInfoFlag<"FrontendOpts.FixOnlyWarnings", "false">; + MarshallingInfoFlag<"FrontendOpts.FixOnlyWarnings">; def fixit_recompile : Flag<["-"], "fixit-recompile">, HelpText<"Apply fix-it changes and recompile">, - MarshallingInfoFlag<"FrontendOpts.FixAndRecompile", "false">; + MarshallingInfoFlag<"FrontendOpts.FixAndRecompile">; def fixit_to_temp : Flag<["-"], "fixit-to-temporary">, HelpText<"Apply fix-it changes to temporary files">, - MarshallingInfoFlag<"FrontendOpts.FixToTemporaries", "false">; + MarshallingInfoFlag<"FrontendOpts.FixToTemporaries">; 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 ast_dump_filter : Separate<["-"], "ast-dump-filter">, MetaVarName<"">, @@ -680,7 +681,7 @@ def version : Flag<["-"], "version">, HelpText<"Print the compiler version">, - MarshallingInfoFlag<"FrontendOpts.ShowVersion", "false">; + MarshallingInfoFlag<"FrontendOpts.ShowVersion">; } // Flags = [CC1Option, CC1AsOption, NoDriverOption] @@ -734,21 +735,21 @@ MarshallingInfoBooleanFlag<"CodeGenOpts.EmitVersionIdentMetadata", "true", Qn>; def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group, Flags<[CC1Option]>, HelpText<"OpenCL only. Generate kernel argument metadata.">, - MarshallingInfoFlag<"CodeGenOpts.EmitOpenCLArgMetadata", "false">; + MarshallingInfoFlag<"CodeGenOpts.EmitOpenCLArgMetadata">; def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group, Flags<[CC1Option]>, HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">, - MarshallingInfoFlag<"CodeGenOpts.LessPreciseFPMAD", "false">; + MarshallingInfoFlag<"CodeGenOpts.LessPreciseFPMAD">; def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group, Flags<[CC1Option]>, HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">, - MarshallingInfoFlag<"CodeGenOpts.CorrectlyRoundedDivSqrt", "false">; + MarshallingInfoFlag<"CodeGenOpts.CorrectlyRoundedDivSqrt">; def cl_uniform_work_group_size : Flag<["-"], "cl-uniform-work-group-size">, Group, Flags<[CC1Option]>, HelpText<"OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel">, - MarshallingInfoFlag<"CodeGenOpts.UniformWGSize", "false">; + MarshallingInfoFlag<"CodeGenOpts.UniformWGSize">; def fautolink : Flag<["-"], "fautolink">, Group; def fno_autolink : Flag<["-"], "fno-autolink">, Flags<[CC1Option]>, Group, HelpText<"Disable generation of linker directives for automatic library linking">, - MarshallingInfoFlag<"CodeGenOpts.Autolink", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.Autolink">; def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">, Group, Flags<[DriverOption, CC1Option]>, HelpText<"Specifies that the sample profile is accurate">, @@ -756,7 +757,7 @@ profile is accurate, callsites without profile samples are marked as cold. Otherwise, treat callsites without profile samples as if we have no profile}]>, - MarshallingInfoFlag<"CodeGenOpts.ProfileSampleAccurate", "false">; + MarshallingInfoFlag<"CodeGenOpts.ProfileSampleAccurate">; defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling", "Emit extra debug info to make sample profile more accurate", "", "", [], "CodeGenOpts.DebugInfoForProfiling">; defm coverage_mapping : OptInFFlag<"coverage-mapping", @@ -765,7 +766,7 @@ defm addrsig : OptInFFlag<"addrsig", "Emit", "Don't emit", " an address-significance table", [CoreOption], "CodeGenOpts.Addrsig">; def fcommon : Flag<["-"], "fcommon">, Group, Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">, - MarshallingInfoFlag<"CodeGenOpts.NoCommon", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.NoCommon">; defm diagnostics_show_hotness : OptInFFlag<"diagnostics-show-hotness", "Enable profile hotness information in diagnostic line", "", "", [], "CodeGenOpts.DiagnosticsWithHotness">; defm dwarf_directory_asm : OptOutFFlag<"dwarf-directory-asm", "", "", "", [], "CodeGenOpts.NoDwarfDirectoryAsm">; @@ -791,27 +792,27 @@ Group; def fsanitize_address_globals_dead_stripping : Flag<["-"], "fsanitize-address-globals-dead-stripping">, Group, HelpText<"Enable linker dead stripping of globals in AddressSanitizer">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeAddressGlobalsDeadStripping", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeAddressGlobalsDeadStripping">; defm sanitize_address_use_odr_indicator: BooleanMarshalledFFlag<"sanitize-address-use-odr-indicator", "CodeGenOpts.SanitizeAddressUseOdrIndicator", "false", "Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size", "Disable ODR indicator globals">, Group; def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">, - Group, MarshallingInfoFlag<"CodeGenOpts.SanitizeMinimalRuntime", "false">; + Group, MarshallingInfoFlag<"CodeGenOpts.SanitizeMinimalRuntime">; def fsanitize_cfi_cross_dso : Flag<["-"], "fsanitize-cfi-cross-dso">, Group, HelpText<"Enable control flow integrity (CFI) checks for cross-DSO calls.">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCrossDso", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCrossDso">; def fsanitize_cfi_icall_generalize_pointers : Flag<["-"], "fsanitize-cfi-icall-generalize-pointers">, Group, HelpText<"Generalize pointers in CFI indirect call type signature checks">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiICallGeneralizePointers", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiICallGeneralizePointers">; def fsanitize_cfi_canonical_jump_tables : Flag<["-"], "fsanitize-cfi-canonical-jump-tables">, Group, HelpText<"Make the jump table addresses canonical in the symbol table">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCanonicalJumpTables", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCanonicalJumpTables">; def fsanitize_stats : Flag<["-"], "fsanitize-stats">, Group, HelpText<"Enable sanitizer statistics gathering.">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeStats", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeStats">; def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">, Group, HelpText<"Enable origins tracking in MemorySanitizer">, @@ -832,7 +833,7 @@ HelpText<"Assume that overflowing float-to-int casts are undefined (default)">; def fno_strict_float_cast_overflow : Flag<["-"], "fno-strict-float-cast-overflow">, Group, Flags<[CC1Option]>, HelpText<"Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions">, - MarshallingInfoFlag<"CodeGenOpts.StrictFloatCastOverflow", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.StrictFloatCastOverflow">; 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", "", [], "CodeGenOpts.NullPointerIsValid">; @@ -841,13 +842,13 @@ "Disables an experimental new pass manager in LLVM.">, Group, Flags<[CC1Option]>; def finstrument_functions : Flag<["-"], "finstrument-functions">, Group, Flags<[CC1Option]>, HelpText<"Generate calls to instrument function entry and exit">, - MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctions", "false">; + MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctions">; def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group, Flags<[CC1Option]>, HelpText<"Like -finstrument-functions, but insert the calls after inlining">, - MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionsAfterInlining", "false">; + MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionsAfterInlining">; def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group, Flags<[CC1Option]>, HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">, - MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionEntryBare", "false">; + MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionEntryBare">; defm xray_ignore_loops : OptInFFlag<"xray-ignore-loops", "Don't instrument functions with loops unless they also meet the minimum function size", "", "", [], "CodeGenOpts.XRayIgnoreLoops">; defm xray_function_index : OptOutFFlag<"xray-function-index", "", @@ -858,28 +859,28 @@ "Use large-integer access for consecutive bitfield runs.">, Group, Flags<[CC1Option]>; def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group, Flags<[CC1Option, CoreOption]>, HelpText<"Allow merging of constants">, - MarshallingInfoFlag<"CodeGenOpts.MergeAllConstants", "false">; + MarshallingInfoFlag<"CodeGenOpts.MergeAllConstants">; def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group, HelpText<"Disallow merging of constants">; def fms_volatile : Flag<["-"], "fms-volatile">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"CodeGenOpts.MSVolatile", "false">; + MarshallingInfoFlag<"CodeGenOpts.MSVolatile">; def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group, HelpText<"Don't assume that C++'s global operator new can't alias any pointer">, Flags<[CC1Option]>, - MarshallingInfoFlag<"CodeGenOpts.AssumeSaneOperatorNew", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.AssumeSaneOperatorNew">; def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group; def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group, Flags<[CC1Option]>, HelpText<"Don't use __cxa_atexit for calling destructors">, - MarshallingInfoFlag<"CodeGenOpts.CXAAtExit", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.CXAAtExit">; defm register_global_dtors_with_atexit : OptInFFlag<"register-global-dtors-with-atexit", "Use", "Don't use", " atexit or __cxa_atexit to register global destructors", [], "CodeGenOpts.RegisterGlobalDtorsWithAtExit">; def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"CodeGenOpts.AsmVerbose", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.AsmVerbose">; def fobjc_convert_messages_to_runtime_calls : Flag<["-"], "fobjc-convert-messages-to-runtime-calls">, Group; def fno_objc_convert_messages_to_runtime_calls : Flag<["-"], "fno-objc-convert-messages-to-runtime-calls">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"CodeGenOpts.ObjCConvertMessagesToRuntimeCalls", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.ObjCConvertMessagesToRuntimeCalls">; defm objc_arc_exceptions : OptInFFlag<"objc-arc-exceptions", "Use EH-safe code when synthesizing retains and releases in -fobjc-arc", "", "", [], "CodeGenOpts.ObjCAutoRefCountExceptions">; @@ -889,16 +890,16 @@ def fpreserve_as_comments : Flag<["-"], "fpreserve-as-comments">, Group; def fno_preserve_as_comments : Flag<["-"], "fno-preserve-as-comments">, Flags<[CC1Option]>, Group, HelpText<"Do not preserve comments in inline assembly">, - MarshallingInfoFlag<"CodeGenOpts.PreserveAsmComments", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.PreserveAsmComments">; def fstack_clash_protection : Flag<["-"], "fstack-clash-protection">, Group, Flags<[CC1Option]>, HelpText<"Enable stack clash protection">, - MarshallingInfoFlag<"CodeGenOpts.StackClashProtector", "false">; + MarshallingInfoFlag<"CodeGenOpts.StackClashProtector">; def fnostack_clash_protection : Flag<["-"], "fnostack-clash-protection">, Group, HelpText<"Disable stack clash protection">; def fstrict_enums : Flag<["-"], "fstrict-enums">, Group, Flags<[CC1Option]>, HelpText<"Enable optimizations based on the strict definition of an enum's " "value range">, - MarshallingInfoFlag<"CodeGenOpts.StrictEnums", "false">; + MarshallingInfoFlag<"CodeGenOpts.StrictEnums">; defm strict_vtable_pointers : OptInFFlag<"strict-vtable-pointers", "Enable optimizations based on the strict rules for overwriting polymorphic C++ objects", "", "", [], "CodeGenOpts.StrictVTablePointers">; @@ -906,7 +907,7 @@ def fuse_init_array : Flag<["-"], "fuse-init-array">, Group; def fno_use_init_array : Flag<["-"], "fno-use-init-array">, Group, Flags<[CC1Option]>, HelpText<"Use .ctors/.dtors instead of .init_array/.fini_array">, - MarshallingInfoFlag<"CodeGenOpts.UseInitArray", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.UseInitArray">; defm whole_program_vtables : OptInFFlag<"whole-program-vtables", "Enables whole-program vtable optimization. Requires -flto", "", "", [CoreOption], "CodeGenOpts.WholeProgramVTables">; defm split_lto_unit : OptInFFlag<"split-lto-unit", @@ -927,82 +928,82 @@ def funique_section_names : Flag<["-"], "funique-section-names">, Group; def fno_unique_section_names : Flag<["-"], "fno-unique-section-names">, Group, Flags<[CC1Option]>, HelpText<"Don't use unique names for text and data sections">, - MarshallingInfoFlag<"CodeGenOpts.UniqueSectionNames", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.UniqueSectionNames">; def fstrict_return : Flag<["-"], "fstrict-return">, Group; def fno_strict_return : Flag<["-"], "fno-strict-return">, Group, Flags<[CC1Option]>, HelpText<"Don't treat control flow paths that fall off the end of a non-void function as unreachable">, - MarshallingInfoFlag<"CodeGenOpts.StrictReturn", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.StrictReturn">; defm debug_ranges_base_address : OptInFFlag<"debug-ranges-base-address", "Use DWARF base address selection entries in .debug_ranges", "", "", [], "CodeGenOpts.DebugRangesBaseAddress">; def fsplit_dwarf_inlining: Flag <["-"], "fsplit-dwarf-inlining">, 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, - Flags<[CC1Option]>, MarshallingInfoFlag<"CodeGenOpts.SplitDwarfInlining", "true">, IsNegative; + Flags<[CC1Option]>, MarshallingInfoNegativeFlag<"CodeGenOpts.SplitDwarfInlining">; defm force_dwarf_frame : OptInFFlag<"force-dwarf-frame", "Always emit a debug frame section", "", "", [], "CodeGenOpts.ForceDwarfFrameSection">; def gcodeview : Flag<["-"], "gcodeview">, HelpText<"Generate CodeView debug information">, Flags<[CC1Option, CC1AsOption, CoreOption]>, - MarshallingInfoFlag<"CodeGenOpts.EmitCodeView", "false">; + MarshallingInfoFlag<"CodeGenOpts.EmitCodeView">; def gcodeview_ghash : Flag<["-"], "gcodeview-ghash">, HelpText<"Emit type record hashes in a .debug$H section">, Flags<[CC1Option, CoreOption]>, - MarshallingInfoFlag<"CodeGenOpts.CodeViewGHash", "false">; + MarshallingInfoFlag<"CodeGenOpts.CodeViewGHash">; def gno_inline_line_tables : Flag<["-"], "gno-inline-line-tables">, Flags<[CC1Option, CoreOption]>, HelpText<"Don't emit inline line tables">, - MarshallingInfoFlag<"CodeGenOpts.NoInlineLineTables", "false">; + MarshallingInfoFlag<"CodeGenOpts.NoInlineLineTables">; def gno_column_info : Flag<["-"], "gno-column-info">, Group, Flags<[CoreOption, CC1Option]>, - MarshallingInfoFlag<"CodeGenOpts.DebugColumnInfo", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.DebugColumnInfo">; def gembed_source : Flag<["-"], "gembed-source">, Group, Flags<[CC1Option]>, HelpText<"Embed source text in DWARF debug sections">, - MarshallingInfoFlag<"CodeGenOpts.EmbedSource", "false">; + MarshallingInfoFlag<"CodeGenOpts.EmbedSource">; def mstackrealign : Flag<["-"], "mstackrealign">, Group, Flags<[CC1Option]>, HelpText<"Force realign the stack at entry to every function">, - MarshallingInfoFlag<"CodeGenOpts.StackRealignment", "false">; + MarshallingInfoFlag<"CodeGenOpts.StackRealignment">; def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group, Flags<[CC1Option]>, HelpText<"Disable stack probes which are enabled by default">, - MarshallingInfoFlag<"CodeGenOpts.NoStackArgProbe", "false">; + MarshallingInfoFlag<"CodeGenOpts.NoStackArgProbe">; def mno_tls_direct_seg_refs : Flag<["-"], "mno-tls-direct-seg-refs">, Group, Flags<[CC1Option]>, HelpText<"Disable direct TLS access through segment registers">, - MarshallingInfoFlag<"CodeGenOpts.IndirectTlsSegRefs", "false">; + MarshallingInfoFlag<"CodeGenOpts.IndirectTlsSegRefs">; def mspeculative_load_hardening : Flag<["-"], "mspeculative-load-hardening">, Group, Flags<[CoreOption,CC1Option]>, - MarshallingInfoFlag<"CodeGenOpts.SpeculativeLoadHardening", "false">; + MarshallingInfoFlag<"CodeGenOpts.SpeculativeLoadHardening">; def ForceAAPCSBitfieldLoad : Flag<["-"], "fAAPCSBitfieldLoad">, Group, Flags<[DriverOption,CC1Option]>, HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">, - MarshallingInfoFlag<"CodeGenOpts.ForceAAPCSBitfieldLoad", "false">; + MarshallingInfoFlag<"CodeGenOpts.ForceAAPCSBitfieldLoad">; def mbackchain : Flag<["-"], "mbackchain">, Group, Flags<[DriverOption,CC1Option]>, HelpText<"Link stack frames through backchain on System Z">, - MarshallingInfoFlag<"CodeGenOpts.Backchain", "false">; + MarshallingInfoFlag<"CodeGenOpts.Backchain">; def mno_backchain : Flag<["-"], "mno-backchain">, Group, Flags<[DriverOption,CC1Option]>; def mrelax_all : Flag<["-"], "mrelax-all">, Group, Flags<[CC1Option,CC1AsOption]>, HelpText<"(integrated-as) Relax all machine instructions">, - MarshallingInfoFlag<"CodeGenOpts.RelaxAll", "false">; + MarshallingInfoFlag<"CodeGenOpts.RelaxAll">; def mincremental_linker_compatible : Flag<["-"], "mincremental-linker-compatible">, Group, Flags<[CC1Option,CC1AsOption]>, HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">, - MarshallingInfoFlag<"CodeGenOpts.IncrementalLinkerCompatible", "false">; + MarshallingInfoFlag<"CodeGenOpts.IncrementalLinkerCompatible">; def msoft_float : Flag<["-"], "msoft-float">, Group, Flags<[CC1Option]>, HelpText<"Use software floating point">, - MarshallingInfoFlag<"CodeGenOpts.SoftFloat", "false">; + MarshallingInfoFlag<"CodeGenOpts.SoftFloat">; def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group, Flags<[CC1Option]>, HelpText<"Use copy relocations support for PIE builds">, - MarshallingInfoFlag<"CodeGenOpts.PIECopyRelocations", "false">; + MarshallingInfoFlag<"CodeGenOpts.PIECopyRelocations">; def mfentry : Flag<["-"], "mfentry">, HelpText<"Insert calls to fentry at function entry (x86/SystemZ only)">, Flags<[CC1Option]>, Group, - MarshallingInfoFlag<"CodeGenOpts.CallFEntry", "false">; + 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, - MarshallingInfoFlag<"CodeGenOpts.MNopMCount", "false">; + MarshallingInfoFlag<"CodeGenOpts.MNopMCount">; def mrecord_mcount : Flag<["-"], "mrecord-mcount">, HelpText<"Generate a __mcount_loc section entry for each __fentry__ call.">, Flags<[CC1Option]>, Group, - MarshallingInfoFlag<"CodeGenOpts.RecordMCount", "false">; + MarshallingInfoFlag<"CodeGenOpts.RecordMCount">; def mpacked_stack : Flag<["-"], "mpacked-stack">, HelpText<"Use packed stack layout (SystemZ only).">, Flags<[CC1Option]>, Group, - MarshallingInfoFlag<"CodeGenOpts.PackedStack", "false">; + MarshallingInfoFlag<"CodeGenOpts.PackedStack">; def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>, - MarshallingInfoFlag<"CodeGenOpts.InstrumentForProfiling", "false">; + MarshallingInfoFlag<"CodeGenOpts.InstrumentForProfiling">; defm integrated_as : OptOutFFlag<"integrated-as", "Enable", "Disable", " the integrated assembler", [], "CodeGenOpts.DisableIntegratedAS">; def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">, @@ -1080,24 +1081,24 @@ def debug_info_macro : Flag<["-"], "debug-info-macro">, HelpText<"Emit macro debug information">, - MarshallingInfoFlag<"CodeGenOpts.MacroDebugInfo", "false">; + MarshallingInfoFlag<"CodeGenOpts.MacroDebugInfo">; def mno_exec_stack : Flag<["-"], "mnoexecstack">, HelpText<"Mark the file as not needing an executable stack">, - MarshallingInfoFlag<"CodeGenOpts.NoExecStack", "false">; + MarshallingInfoFlag<"CodeGenOpts.NoExecStack">; def massembler_no_warn : Flag<["-"], "massembler-no-warn">, HelpText<"Make assembler not emit warnings">, - MarshallingInfoFlag<"CodeGenOpts.NoWarn", "false">; + MarshallingInfoFlag<"CodeGenOpts.NoWarn">; def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">, HelpText<"Make assembler warnings fatal">, - MarshallingInfoFlag<"CodeGenOpts.FatalWarnings", "false">; + MarshallingInfoFlag<"CodeGenOpts.FatalWarnings">; def mrelax_relocations : Flag<["--"], "mrelax-relocations">, HelpText<"Use relaxable elf relocations">, - MarshallingInfoFlag<"CodeGenOpts.RelaxELFRelocations", "false">; + 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.">, - MarshallingInfoFlag<"CodeGenOpts.SaveTempLabels", "false">; + 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">, @@ -1137,139 +1138,139 @@ def disable_llvm_verifier : Flag<["-"], "disable-llvm-verifier">, HelpText<"Don't run the LLVM IR verifier pass">, - MarshallingInfoFlag<"CodeGenOpts.VerifyModule", "true">, IsNegative; + 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">, - MarshallingInfoFlag<"CodeGenOpts.DisableLLVMPasses", "false">; + MarshallingInfoFlag<"CodeGenOpts.DisableLLVMPasses">; def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">, Alias; def disable_lifetimemarkers : Flag<["-"], "disable-lifetime-markers">, HelpText<"Disable lifetime-markers emission even when optimizations are " "enabled">, - MarshallingInfoFlag<"CodeGenOpts.DisableLifetimeMarkers", "false">; + MarshallingInfoFlag<"CodeGenOpts.DisableLifetimeMarkers">; def disable_O0_optnone : Flag<["-"], "disable-O0-optnone">, HelpText<"Disable adding the optnone attribute to functions at O0">, - MarshallingInfoFlag<"CodeGenOpts.DisableO0ImplyOptNone", "false">; + MarshallingInfoFlag<"CodeGenOpts.DisableO0ImplyOptNone">; def disable_red_zone : Flag<["-"], "disable-red-zone">, HelpText<"Do not emit code that uses the red zone.">, - MarshallingInfoFlag<"CodeGenOpts.DisableRedZone", "false">; + MarshallingInfoFlag<"CodeGenOpts.DisableRedZone">; def dwarf_ext_refs : Flag<["-"], "dwarf-ext-refs">, HelpText<"Generate debug info with external references to clang modules" " or precompiled headers">, - MarshallingInfoFlag<"CodeGenOpts.DebugTypeExtRefs", "false">; + MarshallingInfoFlag<"CodeGenOpts.DebugTypeExtRefs">; def dwarf_explicit_import : Flag<["-"], "dwarf-explicit-import">, HelpText<"Generate explicit import from anonymous namespace to containing" " scope">, - MarshallingInfoFlag<"CodeGenOpts.DebugExplicitImport", "false">; + MarshallingInfoFlag<"CodeGenOpts.DebugExplicitImport">; def debug_forward_template_params : Flag<["-"], "debug-forward-template-params">, HelpText<"Emit complete descriptions of template parameters in forward" " declarations">, - MarshallingInfoFlag<"CodeGenOpts.DebugFwdTemplateParams", "false">; + 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">, - MarshallingInfoFlag<"CodeGenOpts.ForbidGuardVariables", "false">; + MarshallingInfoFlag<"CodeGenOpts.ForbidGuardVariables">; def no_implicit_float : Flag<["-"], "no-implicit-float">, HelpText<"Don't generate implicit floating point instructions">, - MarshallingInfoFlag<"CodeGenOpts.NoImplicitFloat", "false">; + MarshallingInfoFlag<"CodeGenOpts.NoImplicitFloat">; def fmerge_functions : Flag<["-"], "fmerge-functions">, HelpText<"Permit merging of identical functions when optimizing.">, - MarshallingInfoFlag<"CodeGenOpts.MergeFunctions", "false">; + MarshallingInfoFlag<"CodeGenOpts.MergeFunctions">; def femit_coverage_notes : Flag<["-"], "femit-coverage-notes">, HelpText<"Emit a gcov coverage notes file when compiling.">, - MarshallingInfoFlag<"CodeGenOpts.EmitGcovNotes", "false">; + MarshallingInfoFlag<"CodeGenOpts.EmitGcovNotes">; def femit_coverage_data: Flag<["-"], "femit-coverage-data">, HelpText<"Instrument the program to emit gcov coverage data when run.">, - MarshallingInfoFlag<"CodeGenOpts.EmitGcovArcs", "false">; + MarshallingInfoFlag<"CodeGenOpts.EmitGcovArcs">; def test_coverage : Flag<["-"], "test-coverage">, HelpText<"Do not generate coverage files or remove coverage changes from IR">, - MarshallingInfoFlag<"CodeGenOpts.DisableGCov", "false">; + MarshallingInfoFlag<"CodeGenOpts.DisableGCov">; def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">, HelpText<"Dump the coverage mapping records, for testing">, - MarshallingInfoFlag<"CodeGenOpts.DumpCoverageMapping", "false">; + 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.">, - MarshallingInfoFlag<"CodeGenOpts.UseRegisterSizedBitfieldAccess", "false">; + MarshallingInfoFlag<"CodeGenOpts.UseRegisterSizedBitfieldAccess">; def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">, HelpText<"Turn off Type Based Alias Analysis">, - MarshallingInfoFlag<"CodeGenOpts.RelaxedAliasing", "false">; + MarshallingInfoFlag<"CodeGenOpts.RelaxedAliasing">; def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">, HelpText<"Turn off struct-path aware Type Based Alias Analysis">, - MarshallingInfoFlag<"CodeGenOpts.StructPathTBAA", "true">, IsNegative; + MarshallingInfoNegativeFlag<"CodeGenOpts.StructPathTBAA">; def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">, HelpText<"Disable tail call optimization, keeping the call stack accurate">, - MarshallingInfoFlag<"CodeGenOpts.DisableTailCalls", "false">; + MarshallingInfoFlag<"CodeGenOpts.DisableTailCalls">; def split_stacks : Flag<["-"], "split-stacks">, HelpText<"Try to use a split stack if possible.">, - MarshallingInfoFlag<"CodeGenOpts.EnableSegmentedStacks", "false">; + MarshallingInfoFlag<"CodeGenOpts.EnableSegmentedStacks">; def munwind_tables : Flag<["-"], "munwind-tables">, HelpText<"Generate unwinding tables for all functions">, - MarshallingInfoFlag<"CodeGenOpts.UnwindTables", "false">; + MarshallingInfoFlag<"CodeGenOpts.UnwindTables">; def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">, HelpText<"Emit complete constructors and destructors as aliases when possible">, - MarshallingInfoFlag<"CodeGenOpts.CXXCtorDtorAliases", "false">; + MarshallingInfoFlag<"CodeGenOpts.CXXCtorDtorAliases">; def vectorize_loops : Flag<["-"], "vectorize-loops">, HelpText<"Run the Loop vectorization passes">, - MarshallingInfoFlag<"CodeGenOpts.VectorizeLoop", "false">; + MarshallingInfoFlag<"CodeGenOpts.VectorizeLoop">; def vectorize_slp : Flag<["-"], "vectorize-slp">, HelpText<"Run the SLP vectorization passes">, - MarshallingInfoFlag<"CodeGenOpts.VectorizeSLP", "false">; + MarshallingInfoFlag<"CodeGenOpts.VectorizeSLP">; def fsanitize_coverage_indirect_calls : Flag<["-"], "fsanitize-coverage-indirect-calls">, HelpText<"Enable sanitizer coverage for indirect calls">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageIndirectCalls", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageIndirectCalls">; def fsanitize_coverage_trace_bb : Flag<["-"], "fsanitize-coverage-trace-bb">, HelpText<"Enable basic block tracing in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceBB", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceBB">; def fsanitize_coverage_trace_cmp : Flag<["-"], "fsanitize-coverage-trace-cmp">, HelpText<"Enable cmp instruction tracing in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceCmp", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceCmp">; def fsanitize_coverage_trace_div : Flag<["-"], "fsanitize-coverage-trace-div">, HelpText<"Enable div instruction tracing in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceDiv", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceDiv">; def fsanitize_coverage_trace_gep : Flag<["-"], "fsanitize-coverage-trace-gep">, HelpText<"Enable gep instruction tracing in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceGep", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceGep">; def fsanitize_coverage_8bit_counters : Flag<["-"], "fsanitize-coverage-8bit-counters">, HelpText<"Enable frequency counters in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverage8bitCounters", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverage8bitCounters">; def fsanitize_coverage_inline_8bit_counters : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">, HelpText<"Enable inline 8-bit counters in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInline8bitCounters", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInline8bitCounters">; def fsanitize_coverage_inline_bool_flag : Flag<["-"], "fsanitize-coverage-inline-bool-flag">, HelpText<"Enable inline bool flag in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInlineBoolFlag", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInlineBoolFlag">; def fsanitize_coverage_pc_table : Flag<["-"], "fsanitize-coverage-pc-table">, HelpText<"Create a table of coverage-instrumented PCs">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoveragePCTable", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoveragePCTable">; def fsanitize_coverage_trace_pc : Flag<["-"], "fsanitize-coverage-trace-pc">, HelpText<"Enable PC tracing in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePC", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePC">; def fsanitize_coverage_trace_pc_guard : Flag<["-"], "fsanitize-coverage-trace-pc-guard">, HelpText<"Enable PC tracing with guard in sanitizer coverage">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePCGuard", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePCGuard">; def fsanitize_coverage_no_prune : Flag<["-"], "fsanitize-coverage-no-prune">, HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageNoPrune", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageNoPrune">; def fsanitize_coverage_stack_depth : Flag<["-"], "fsanitize-coverage-stack-depth">, HelpText<"Enable max stack depth tracing">, - MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageStackDepth", "false">; + MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageStackDepth">; def flto_visibility_public_std: Flag<["-"], "flto-visibility-public-std">, HelpText<"Use public LTO visibility for classes in std and stdext namespaces">, - MarshallingInfoFlag<"CodeGenOpts.LTOVisibilityPublicStd", "false">; + MarshallingInfoFlag<"CodeGenOpts.LTOVisibilityPublicStd">; defm lto_unit : BooleanMarshalledFFlag<"lto-unit", "CodeGenOpts.LTOUnit", "false", "Emit IR to support LTO unit features (CFI, whole program vtable opt)">; defm debug_pass_manager : BooleanMarshalledFFlag<"debug-pass-manager", "CodeGenOpts.DebugPassManager", @@ -1277,13 +1278,13 @@ "Disables debug information for the new pass manager">; def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">, HelpText<"Emit Windows Control Flow Guard tables only (no checks)">, - MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuardNoChecks", "false">; + MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuardNoChecks">; def cfguard : Flag<["-"], "cfguard">, HelpText<"Emit Windows Control Flow Guard tables and checks">, - MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuard", "false">; + MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuard">; def discard_value_names : Flag<["-"], "discard-value-names">, HelpText<"Discard value names in LLVM IR">, - MarshallingInfoFlag<"CodeGenOpts.DiscardValueNames", "false">; + MarshallingInfoFlag<"CodeGenOpts.DiscardValueNames">; def no_emit_llvm_uselists : Flag<["-"], "no-emit-llvm-uselists">, HelpText<"Don't preserve order of LLVM use-lists when serializing">; def emit_llvm_uselists : Flag<["-"], "emit-llvm-uselists">, @@ -1291,7 +1292,7 @@ MarshallingInfoBooleanFlag<"CodeGenOpts.EmitLLVMUseLists", "false", no_emit_llvm_uselists>; def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">, HelpText<"Preserve 3-component vector type">, - MarshallingInfoFlag<"CodeGenOpts.PreserveVec3Type", "false">; + MarshallingInfoFlag<"CodeGenOpts.PreserveVec3Type">; def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">, HelpText<"Incorporate CUDA device-side binary into host object file.">, @@ -1361,15 +1362,15 @@ Group, Flags<[CC1Option]>, HelpText<"Don't verify input files for the modules if the module has been " "successfully validated or loaded during this build session">, - MarshallingInfoFlag<"HeaderSearchOpts->ModulesValidateOncePerBuildSession", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->ModulesValidateOncePerBuildSession">; def fmodules_disable_diagnostic_validation : Flag<["-"], "fmodules-disable-diagnostic-validation">, Group, Flags<[CC1Option]>, HelpText<"Disable validation of the diagnostic options when loading the module">, - MarshallingInfoFlag<"HeaderSearchOpts->ModulesValidateDiagnosticOptions", "true">, IsNegative; + MarshallingInfoNegativeFlag<"HeaderSearchOpts->ModulesValidateDiagnosticOptions">; def fmodules_validate_system_headers : Flag<["-"], "fmodules-validate-system-headers">, Group, Flags<[CC1Option]>, HelpText<"Validate the system headers that a module depends on when loading the module">, - MarshallingInfoFlag<"HeaderSearchOpts->ModulesValidateSystemHeaders", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->ModulesValidateSystemHeaders">; def fno_modules_validate_system_headers : Flag<["-"], "fno-modules-validate-system-headers">, Group, Flags<[DriverOption]>; def fvalidate_ast_input_files_content: @@ -1378,20 +1379,20 @@ HelpText<"Compute and store the hash of input files used to build an AST." " Files with mismatching mtime's are considered valid" " if both contents is identical">, - MarshallingInfoFlag<"HeaderSearchOpts->ValidateASTInputFilesContent", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->ValidateASTInputFilesContent">; def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group, Flags<[DriverOption, CC1Option]>, HelpText<"Implicitly search the file system for module map files.">, - MarshallingInfoFlag<"HeaderSearchOpts->ImplicitModuleMaps", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->ImplicitModuleMaps">; def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>, HelpText<"Disable builtin #include directories">, - MarshallingInfoFlag<"HeaderSearchOpts->UseBuiltinIncludes", "true">, IsNegative; + MarshallingInfoNegativeFlag<"HeaderSearchOpts->UseBuiltinIncludes">; 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 v : Flag<["-"], "v">, Flags<[CC1Option, CoreOption]>, HelpText<"Show commands to run and use verbose output">, - MarshallingInfoFlag<"HeaderSearchOpts->Verbose", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->Verbose">; def fmodules_user_build_path : Separate<["-"], "fmodules-user-build-path">, Group, Flags<[DriverOption, CC1Option]>, MetaVarName<"">, @@ -1422,20 +1423,20 @@ 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=">, - MarshallingInfoFlag<"HeaderSearchOpts->ModuleMapFileHomeIsCwd", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->ModuleMapFileHomeIsCwd">; 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", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->DisableModuleHash">; def fmodules_hash_content : Flag<["-"], "fmodules-hash-content">, HelpText<"Enable hashing the content of a module file">, - MarshallingInfoFlag<"HeaderSearchOpts->ModulesHashContent", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->ModulesHashContent">; def fmodules_strict_context_hash : Flag<["-"], "fmodules-strict-context-hash">, HelpText<"Enable hashing of all compiler options that could impact the " "semantics of a module in an implicit build">, - MarshallingInfoFlag<"HeaderSearchOpts->ModulesStrictContextHash", "false">; + MarshallingInfoFlag<"HeaderSearchOpts->ModulesStrictContextHash">; def fmodule_format_EQ : Joined<["-"], "fmodule-format=">, HelpText<"Select the container format for clang modules and PCH. " @@ -1448,81 +1449,81 @@ def cl_single_precision_constant : Flag<["-"], "cl-single-precision-constant">, Group, Flags<[CC1Option]>, HelpText<"OpenCL only. Treat double precision floating-point constant as single precision constant.">, - MarshallingInfoFlag<"LangOpts->SinglePrecisionConstants", "false">; + MarshallingInfoFlag<"LangOpts->SinglePrecisionConstants">; def cl_fast_relaxed_math : Flag<["-"], "cl-fast-relaxed-math">, Group, Flags<[CC1Option]>, HelpText<"OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.">, - MarshallingInfoFlag<"LangOpts->FastRelaxedMath", "false">; + MarshallingInfoFlag<"LangOpts->FastRelaxedMath">; defm gpu_rdc : OptInFFlag<"gpu-rdc", "Generate relocatable device code, also known as separate compilation mode", "", "", [], "LangOpts->GPURelocatableDeviceCode">; defm hip_new_launch_api : OptInFFlag<"hip-new-launch-api", "Use", "Don't use", " new kernel launching API for HIP", [], "LangOpts->HIPUseNewLaunchAPI">; def faccess_control : Flag<["-"], "faccess-control">, Group; def fno_access_control : Flag<["-"], "fno-access-control">, Group, Flags<[CC1Option]>, - HelpText<"Disable C++ access control">, MarshallingInfoFlag<"LangOpts->AccessControl", "true">, IsNegative; + HelpText<"Disable C++ access control">, MarshallingInfoNegativeFlag<"LangOpts->AccessControl">; defm allow_editor_placeholders : OptInFFlag<"allow-editor-placeholders", "Treat editor placeholders as valid source code", "", "", [], "LangOpts->AllowEditorPlaceholders">; def fcomplete_member_pointers : Flag<["-"], "fcomplete-member-pointers">, Group, Flags<[CoreOption, CC1Option]>, HelpText<"Require member pointer base types to be complete if they would be significant under the Microsoft ABI">, - MarshallingInfoFlag<"LangOpts->CompleteMemberPointers", "false">; + MarshallingInfoFlag<"LangOpts->CompleteMemberPointers">; def fno_complete_member_pointers : Flag<["-"], "fno-complete-member-pointers">, Group, Flags<[CoreOption]>, HelpText<"Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI">; def fgnu_inline_asm : Flag<["-"], "fgnu-inline-asm">, Group; def fno_gnu_inline_asm : Flag<["-"], "fno-gnu-inline-asm">, Group, Flags<[CC1Option]>, - HelpText<"Disable GNU style inline asm">, MarshallingInfoFlag<"LangOpts->GNUAsm", "true">, IsNegative; + HelpText<"Disable GNU style inline asm">, MarshallingInfoNegativeFlag<"LangOpts->GNUAsm">; def fapple_kext : Flag<["-"], "fapple-kext">, Group, Flags<[CC1Option]>, - HelpText<"Use Apple's kernel extensions ABI">, MarshallingInfoFlag<"LangOpts->AppleKext", "false">; + HelpText<"Use Apple's kernel extensions ABI">, MarshallingInfoFlag<"LangOpts->AppleKext">; defm apple_pragma_pack : OptInFFlag<"apple-pragma-pack", "Enable Apple gcc-compatible #pragma pack handling", "", "", [], "LangOpts->ApplePragmaPack">; defm borland_extensions : OptInFFlag<"borland-extensions", "Accept non-standard constructs supported by the Borland compiler", "", "", [], "LangOpts->Borland">; def fexperimental_new_constant_interpreter : Flag<["-"], "fexperimental-new-constant-interpreter">, Group, HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->EnableNewConstInterp", "false">; + MarshallingInfoFlag<"LangOpts->EnableNewConstInterp">; defm cxx_exceptions: OptInFFlag<"cxx-exceptions", "Enable C++ exceptions", "", "", [], "LangOpts->CXXExceptions">; def femit_all_decls : Flag<["-"], "femit-all-decls">, Group, Flags<[CC1Option]>, HelpText<"Emit all declarations, even if unused">, - MarshallingInfoFlag<"LangOpts->EmitAllDecls", "false">; + MarshallingInfoFlag<"LangOpts->EmitAllDecls">; defm exceptions : OptInFFlag<"exceptions", "Enable", "Disable", " support for exception handling", [], "LangOpts->Exceptions">; def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group, Flags<[CC1Option]>, HelpText<"Use DWARF style exceptions">, - MarshallingInfoFlag<"LangOpts->DWARFExceptions", "false">; + MarshallingInfoFlag<"LangOpts->DWARFExceptions">; def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group, Flags<[CC1Option]>, HelpText<"Use SjLj style exceptions">, - MarshallingInfoFlag<"LangOpts->SjLjExceptions", "false">; + MarshallingInfoFlag<"LangOpts->SjLjExceptions">; def fseh_exceptions : Flag<["-"], "fseh-exceptions">, Group, Flags<[CC1Option]>, HelpText<"Use SEH style exceptions">, - MarshallingInfoFlag<"LangOpts->SEHExceptions", "false">; + MarshallingInfoFlag<"LangOpts->SEHExceptions">; def fwasm_exceptions : Flag<["-"], "fwasm-exceptions">, Group, Flags<[CC1Option]>, HelpText<"Use WebAssembly style exceptions">, - MarshallingInfoFlag<"LangOpts->WasmExceptions", "false">; + MarshallingInfoFlag<"LangOpts->WasmExceptions">; def fignore_exceptions : Flag<["-"], "fignore-exceptions">, Group, Flags<[CC1Option]>, HelpText<"Enable support for ignoring exception handling constructs">, - MarshallingInfoFlag<"LangOpts->IgnoreExceptions", "false">; + MarshallingInfoFlag<"LangOpts->IgnoreExceptions">; defm fast_math : OptInFFlag<"fast-math", "Allow aggressive, lossy floating-point, optimizations", "", "", [], "LangOpts->FastMath">; def fcxx_static_destructors : Flag<["-"], "fc++-static-destructors">, Group; def fno_cxx_static_destructors : Flag<["-"], "fno-c++-static-destructors">, Group, Flags<[CC1Option]>, HelpText<"Disable C++ static destructor registration">, - MarshallingInfoFlag<"LangOpts->RegisterStaticDestructors", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->RegisterStaticDestructors">; defm reciprocal_math : OptInFFlag< "reciprocal-math", "Allow division operations to be reassociated", "", "", [], "LangOpts->AllowRecip">; def fapprox_func : Flag<["-"], "fapprox-func">, Group, Flags<[CC1Option, NoDriverOption]>, - MarshallingInfoFlag<"LangOpts->ApproxFunc", "false">; + MarshallingInfoFlag<"LangOpts->ApproxFunc">; defm finite_math_only : OptInFFlag<"finite-math-only", "", "", "", [], "LangOpts->FiniteMathOnly">; defm signed_zeros : OptOutFFlag<"signed-zeros", "Allow optimizations that ignore the sign of floating point zeros", "", "", [], "LangOpts->NoSignedZero">; def frounding_math : Flag<["-"], "frounding-math">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->FPRoundingMode", "llvm::RoundingMode::NearestTiesToEven">, + MarshallingInfoFlag<"LangOpts->FPRoundingMode">, DefaultValue<"llvm::RoundingMode::NearestTiesToEven">, Normalizer<"(normalizeFlagToValue)">; def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group, Flags<[CC1Option]>; def ffreestanding : Flag<["-"], "ffreestanding">, Group, Flags<[CC1Option]>, HelpText<"Assert that the compilation takes place in a freestanding environment">, - MarshallingInfoFlag<"LangOpts->Freestanding", "false">; + MarshallingInfoFlag<"LangOpts->Freestanding">; def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->HeinousExtensions", "false">; + MarshallingInfoFlag<"LangOpts->HeinousExtensions">; def fexperimental_strict_floating_point : Flag<["-"], "fexperimental-strict-floating-point">, Group, Flags<[CC1Option]>, HelpText<"Enables experimental strict floating point in LLVM.">, - MarshallingInfoFlag<"LangOpts->ExpStrictFP", "false">; + MarshallingInfoFlag<"LangOpts->ExpStrictFP">; defm xray_instrument : OptInFFlag<"xray-instrument", "Generate XRay instrumentation sleds on function entry and exit", "", "", [], "LangOpts->XRayInstrument">; defm xray_always_emit_customevents : OptInFFlag<"xray-always-emit-customevents", "Always emit __xray_customevent(...) calls even if the containing function is not always instrumented", "", "", [], "LangOpts->XRayAlwaysEmitCustomEvents">; @@ -1534,7 +1535,7 @@ "Do not use the experimental C++ class ABI for classes with virtual tables">, Group, Flags<[CC1Option]>; def fms_compatibility : Flag<["-"], "fms-compatibility">, Group, Flags<[CC1Option, CoreOption]>, HelpText<"Enable full Microsoft Visual C++ compatibility">, - MarshallingInfoFlag<"LangOpts->MSVCCompat", "false">; + MarshallingInfoFlag<"LangOpts->MSVCCompat">; defm delayed_template_parsing : OptInFFlag<"delayed-template-parsing", "Parse templated function definitions at the end of the translation unit", "", "", [CoreOption], "LangOpts->DelayedTemplateParsing">; @@ -1542,25 +1543,25 @@ "", "", [], "LangOpts->PCHInstantiateTemplates">; def fmodules_ts : Flag <["-"], "fmodules-ts">, Group, Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">, - MarshallingInfoFlag<"LangOpts->ModulesTS", "false">; + MarshallingInfoFlag<"LangOpts->ModulesTS">; def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group, Flags<[DriverOption,CC1Option]>, HelpText<"Like -fmodules-decluse but requires all headers to be in modules">, - MarshallingInfoFlag<"LangOpts->ModulesStrictDeclUse", "false">; + MarshallingInfoFlag<"LangOpts->ModulesStrictDeclUse">; def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->RetainCommentsFromSystemHeaders", "false">; + MarshallingInfoFlag<"LangOpts->RetainCommentsFromSystemHeaders">; defm constant_cfstrings : OptOutFFlag<"constant-cfstrings", "", "Disable creation of CodeFoundation-type constant strings", "", [], "LangOpts->NoConstantCFStrings">; def felide_constructors : Flag<["-"], "felide-constructors">, Group; def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group, HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->ElideConstructors", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->ElideConstructors">; def fimplicit_modules : Flag <["-"], "fimplicit-modules">, Group, Flags<[DriverOption]>; def fno_implicit_modules : Flag <["-"], "fno-implicit-modules">, Group, Flags<[DriverOption, CC1Option]>, - MarshallingInfoFlag<"LangOpts->ImplicitModules", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->ImplicitModules">; defm objc_arc : OptInFFlag<"objc-arc", "Synthesize retain and release calls for Objective-C pointers", "", "", [], "LangOpts->ObjCAutoRefCount">; defm objc_exceptions : OptInFFlag<"objc-exceptions", "Enable Objective-C exceptions", @@ -1575,10 +1576,10 @@ def fno_objc_infer_related_result_type : Flag<["-"], "fno-objc-infer-related-result-type">, Group, HelpText<"do not infer Objective-C related result type based on method family">, - Flags<[CC1Option]>, MarshallingInfoFlag<"LangOpts->ObjCInferRelatedResultType", "true">, IsNegative; + Flags<[CC1Option]>, MarshallingInfoNegativeFlag<"LangOpts->ObjCInferRelatedResultType">; def fopenmp : Flag<["-"], "fopenmp">, Group, Flags<[CC1Option, NoArgumentUnused]>, HelpText<"Parse OpenMP pragmas and generate parallel code.">, - MarshallingInfoFlag<"LangOpts->OpenMP", "0u">, Normalizer<"(normalizeFlagToValue)">; + MarshallingInfoFlag<"LangOpts->OpenMP">, DefaultValue<"0u">, Normalizer<"(normalizeFlagToValue)">; def fno_openmp : Flag<["-"], "fno-openmp">, Group, Flags<[NoArgumentUnused]>; defm openmp_optimistic_collapse : OptInFFlag<"openmp-optimistic-collapse", "", "", "", [NoArgumentUnused, HelpHidden], "LangOpts->OpenMPOptimisticCollapse">; @@ -1592,56 +1593,56 @@ def fspell_checking : Flag<["-"], "fspell-checking">, Group; def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group, Flags<[CC1Option]>, HelpText<"Disable spell-checking">, - MarshallingInfoFlag<"LangOpts->SpellChecking", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->SpellChecking">; def fthreadsafe_statics : Flag<["-"], "fthreadsafe-statics">, Group; def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group, Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">, - MarshallingInfoFlag<"LangOpts->ThreadsafeStatics", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->ThreadsafeStatics">; def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group, HelpText<"Give inline C++ member functions hidden visibility by default">, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->InlineVisibilityHidden", "false">; + MarshallingInfoFlag<"LangOpts->InlineVisibilityHidden">; def fvisibility_global_new_delete_hidden : Flag<["-"], "fvisibility-global-new-delete-hidden">, Group, HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->GlobalAllocationFunctionVisibilityHidden", "false">; + MarshallingInfoFlag<"LangOpts->GlobalAllocationFunctionVisibilityHidden">; def fwritable_strings : Flag<["-"], "fwritable-strings">, Group, Flags<[CC1Option]>, HelpText<"Store string literals as writable data">, - MarshallingInfoFlag<"LangOpts->WritableStrings", "false">; + MarshallingInfoFlag<"LangOpts->WritableStrings">; def fenable_matrix : Flag<["-"], "fenable-matrix">, Group, Flags<[CC1Option]>, HelpText<"Enable matrix data type and related builtin functions">, - MarshallingInfoFlag<"LangOpts->MatrixTypes", "false">; + MarshallingInfoFlag<"LangOpts->MatrixTypes">; def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group, Flags<[DriverOption,CC1Option]>, HelpText<"Enable hexagon-qdsp6 backward compatibility">, - MarshallingInfoFlag<"LangOpts->HexagonQdsp6Compat", "false">; + MarshallingInfoFlag<"LangOpts->HexagonQdsp6Compat">; def malign_double : Flag<["-"], "malign-double">, Group, Flags<[CC1Option]>, HelpText<"Align doubles to two words in structs (x86 only)">, - MarshallingInfoFlag<"LangOpts->AlignDouble", "false">; + MarshallingInfoFlag<"LangOpts->AlignDouble">; def mms_bitfields : Flag<["-"], "mms-bitfields">, Group, Flags<[CC1Option]>, HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">, - MarshallingInfoFlag<"LangOpts->MSBitfields", "false">; + MarshallingInfoFlag<"LangOpts->MSBitfields">; def mcmse : Flag<["-"], "mcmse">, Group, Flags<[DriverOption,CC1Option]>, HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">, - MarshallingInfoFlag<"LangOpts->Cmse", "false">; + MarshallingInfoFlag<"LangOpts->Cmse">; defm zvector : OptInFFlag<"zvector", "Enable System z vector language extension", "", "", [], "LangOpts->ZVector">; def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>, HelpText<"Enable Objective-C Ivar layout bitmap print trace">, - MarshallingInfoFlag<"LangOpts->ObjCGCBitmapPrint", "false">; + MarshallingInfoFlag<"LangOpts->ObjCGCBitmapPrint">; def pthread : Flag<["-"], "pthread">, Flags<[CC1Option]>, HelpText<"Support POSIX threads in generated code">, - MarshallingInfoFlag<"LangOpts->POSIXThreads", "false">; + MarshallingInfoFlag<"LangOpts->POSIXThreads">; def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, Flags<[CC1Option]>, HelpText<"Enable some traditional CPP emulation">, - MarshallingInfoFlag<"LangOpts->TraditionalCPP", "false">; + MarshallingInfoFlag<"LangOpts->TraditionalCPP">; def fsemantic_interposition : Flag<["-"], "fsemantic-interposition">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->SemanticInterposition", "false">; + MarshallingInfoFlag<"LangOpts->SemanticInterposition">; // An explicit -fno-semantic-interposition infers dso_local. def fno_semantic_interposition: Flag<["-"], "fno-semantic-interposition">, Group, Flags<[CC1Option]>, - MarshallingInfoFlag<"LangOpts->ExplicitNoSemanticInterposition", "false">; + MarshallingInfoFlag<"LangOpts->ExplicitNoSemanticInterposition">; def fsycl : Flag<["-"], "fsycl">, Group, Flags<[CC1Option, CoreOption]>, HelpText<"Enable SYCL kernels compilation for device">, - MarshallingInfoFlag<"LangOpts->SYCL", "false">; + MarshallingInfoFlag<"LangOpts->SYCL">; def fno_sycl : Flag<["-"], "fno-sycl">, Group, Flags<[CoreOption]>, HelpText<"Disable SYCL kernels compilation for device">; @@ -1710,7 +1711,7 @@ def fno_math_builtin : Flag<["-"], "fno-math-builtin">, HelpText<"Disable implicit builtin knowledge of math functions">, - MarshallingInfoFlag<"LangOpts->NoMathBuiltin", "false">; + MarshallingInfoFlag<"LangOpts->NoMathBuiltin">; } // Flags = [CC1Option, CC1AsOption, NoDriverOption] @@ -1718,117 +1719,117 @@ def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">, HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">, - MarshallingInfoFlag<"LangOpts->DumpVTableLayouts", "false">; + MarshallingInfoFlag<"LangOpts->DumpVTableLayouts">; def menable_no_infinities : Flag<["-"], "menable-no-infs">, HelpText<"Allow optimization to assume there are no infinities.">, - MarshallingInfoFlag<"LangOpts->NoHonorInfs", "false">; + MarshallingInfoFlag<"LangOpts->NoHonorInfs">; def menable_no_nans : Flag<["-"], "menable-no-nans">, HelpText<"Allow optimization to assume there are no NaNs.">, - MarshallingInfoFlag<"LangOpts->NoHonorNaNs", "false">; + MarshallingInfoFlag<"LangOpts->NoHonorNaNs">; def menable_unsafe_fp_math : Flag<["-"], "menable-unsafe-fp-math">, HelpText<"Allow unsafe floating-point math optimizations which may decrease " "precision">, - MarshallingInfoFlag<"LangOpts->UnsafeFPMath", "false">; + MarshallingInfoFlag<"LangOpts->UnsafeFPMath">; def mreassociate : Flag<["-"], "mreassociate">, HelpText<"Allow reassociation transformations for floating-point instructions">, - MarshallingInfoFlag<"LangOpts->AllowFPReassoc", "false">; + MarshallingInfoFlag<"LangOpts->AllowFPReassoc">; def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">, HelpText<"Use IEEE 754 quadruple-precision for long double">, - MarshallingInfoFlag<"LangOpts->PPCIEEELongDouble", "false">; + MarshallingInfoFlag<"LangOpts->PPCIEEELongDouble">; def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">, - MarshallingInfoFlag<"LangOpts->BranchTargetEnforcement", "false">; + MarshallingInfoFlag<"LangOpts->BranchTargetEnforcement">; def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">, - MarshallingInfoFlag<"LangOpts->DllExportInlines", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->DllExportInlines">; def fno_modules_error_recovery : Flag<["-"], "fno-modules-error-recovery">, HelpText<"Do not automatically import modules for error recovery">, - MarshallingInfoFlag<"LangOpts->ModulesErrorRecovery", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->ModulesErrorRecovery">; 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">, - MarshallingInfoFlag<"LangOpts->ModulesCodegen", "false">; + 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">, - MarshallingInfoFlag<"LangOpts->ModulesDebugInfo", "false">; + MarshallingInfoFlag<"LangOpts->ModulesDebugInfo">; def fno_concept_satisfaction_caching : Flag<["-"], "fno-concept-satisfaction-caching">, HelpText<"Disable satisfaction caching for C++2a Concepts.">, - MarshallingInfoFlag<"LangOpts->ConceptSatisfactionCaching", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->ConceptSatisfactionCaching">; defm recovery_ast_type : BooleanMarshalledFFlag<"recovery-ast-type", "LangOpts->RecoveryASTType", "false", "Preserve the type for recovery expressions when possible (experimental)">; def fdump_record_layouts_simple : Flag<["-"], "fdump-record-layouts-simple">, HelpText<"Dump record layout information in a simple form used for testing">, - MarshallingInfoFlag<"LangOpts->DumpRecordLayoutsSimple", "false">; + MarshallingInfoFlag<"LangOpts->DumpRecordLayoutsSimple">; def building_pch_with_obj : Flag<["-"], "building-pch-with-obj">, HelpText<"This compilation is part of building a PCH with corresponding object file.">, - MarshallingInfoFlag<"LangOpts->BuildingPCHWithObjectFile", "false">; + MarshallingInfoFlag<"LangOpts->BuildingPCHWithObjectFile">; def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">, HelpText<"Weakly link in the blocks runtime">, - MarshallingInfoFlag<"LangOpts->BlocksRuntimeOptional", "false">; + MarshallingInfoFlag<"LangOpts->BlocksRuntimeOptional">; def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">, HelpText<"Assume all functions with C linkage do not unwind">, - MarshallingInfoFlag<"LangOpts->ExternCNoUnwind", "false">; + MarshallingInfoFlag<"LangOpts->ExternCNoUnwind">; def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">, HelpText<"disable the default synthesis of Objective-C properties">, - MarshallingInfoFlag<"LangOpts->ObjCDefaultSynthProperties", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->ObjCDefaultSynthProperties">; def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">, HelpText<"enable extended encoding of block type signature">, - MarshallingInfoFlag<"LangOpts->EncodeExtendedBlockSig", "false">; + MarshallingInfoFlag<"LangOpts->EncodeExtendedBlockSig">; def pic_is_pie : Flag<["-"], "pic-is-pie">, HelpText<"File is for a position independent executable">, - MarshallingInfoFlag<"LangOpts->PIE", "false">; + MarshallingInfoFlag<"LangOpts->PIE">; def static_define : Flag<["-"], "static-define">, HelpText<"Should __STATIC__ be defined">, - MarshallingInfoFlag<"LangOpts->Static", "false">; + MarshallingInfoFlag<"LangOpts->Static">; def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">, HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">, - MarshallingInfoFlag<"LangOpts->SetVisibilityForExternDecls", "false">; + MarshallingInfoFlag<"LangOpts->SetVisibilityForExternDecls">; defm const_strings : BooleanMarshalledFFlag<"const-strings", "LangOpts->ConstStrings", "false", "Use a const qualified type for string literals in C and ObjC", "Don't use a const qualified type for string literals in C and ObjC">; def fno_bitfield_type_align : Flag<["-"], "fno-bitfield-type-align">, HelpText<"Ignore bit-field types when aligning structures">, - MarshallingInfoFlag<"LangOpts->NoBitFieldTypeAlign", "false">; + MarshallingInfoFlag<"LangOpts->NoBitFieldTypeAlign">; def ffake_address_space_map : Flag<["-"], "ffake-address-space-map">, HelpText<"Use a fake address space map; OpenCL testing purposes only">, - MarshallingInfoFlag<"LangOpts->FakeAddressSpaceMap", "false">; + MarshallingInfoFlag<"LangOpts->FakeAddressSpaceMap">; def funknown_anytype : Flag<["-"], "funknown-anytype">, HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">, - MarshallingInfoFlag<"LangOpts->ParseUnknownAnytype", "false">; + MarshallingInfoFlag<"LangOpts->ParseUnknownAnytype">; def fdebugger_support : Flag<["-"], "fdebugger-support">, HelpText<"Enable special debugger support behavior">, - MarshallingInfoFlag<"LangOpts->DebuggerSupport", "false">; + MarshallingInfoFlag<"LangOpts->DebuggerSupport">; def fdebugger_cast_result_to_id : Flag<["-"], "fdebugger-cast-result-to-id">, HelpText<"Enable casting unknown expression results to id">, - MarshallingInfoFlag<"LangOpts->DebuggerCastResultToId", "false">; + MarshallingInfoFlag<"LangOpts->DebuggerCastResultToId">; def fdebugger_objc_literal : Flag<["-"], "fdebugger-objc-literal">, HelpText<"Enable special debugger support for Objective-C subscripting and literals">, - MarshallingInfoFlag<"LangOpts->DebuggerObjCLiteral", "false">; + MarshallingInfoFlag<"LangOpts->DebuggerObjCLiteral">; defm deprecated_macro : BooleanMarshalledFFlag<"deprecated-macro", "LangOpts->Deprecated", "false", "Defines the __DEPRECATED macro", "Undefines the __DEPRECATED macro">; def finclude_default_header : Flag<["-"], "finclude-default-header">, HelpText<"Include default header file for OpenCL">, - MarshallingInfoFlag<"LangOpts->IncludeDefaultHeader", "false">; + MarshallingInfoFlag<"LangOpts->IncludeDefaultHeader">; def fdeclare_opencl_builtins : Flag<["-"], "fdeclare-opencl-builtins">, HelpText<"Add OpenCL builtin function declarations (experimental)">, - MarshallingInfoFlag<"LangOpts->DeclareOpenCLBuiltins", "false">; + MarshallingInfoFlag<"LangOpts->DeclareOpenCLBuiltins">; defm signed_wchar : BooleanMarshalledFFlag<"signed-wchar", "LangOpts->WCharIsSigned", "true", "Use a signed type for wchar_t", "Use an unsigned type for wchar_t">; 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">, - MarshallingInfoFlag<"LangOpts->CompatibilityQualifiedIdBlockParamTypeChecking", "false">; + MarshallingInfoFlag<"LangOpts->CompatibilityQualifiedIdBlockParamTypeChecking">; def fcuda_is_device : Flag<["-"], "fcuda-is-device">, HelpText<"Generate code for CUDA device">, - MarshallingInfoFlag<"LangOpts->CUDAIsDevice", "false">; + MarshallingInfoFlag<"LangOpts->CUDAIsDevice">; def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">, HelpText<"Allow variadic functions in CUDA device code.">, - MarshallingInfoFlag<"LangOpts->CUDAAllowVariadicFunctions", "false">; + 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__.">, - MarshallingInfoFlag<"LangOpts->CUDAHostDeviceConstexpr", "true">, IsNegative; + MarshallingInfoNegativeFlag<"LangOpts->CUDAHostDeviceConstexpr">; def fconstant_string_class : Separate<["-"], "fconstant-string-class">, MetaVarName<"">, @@ -1900,7 +1901,7 @@ def undef : Flag<["-"], "undef">, Group, Flags<[CC1Option]>, HelpText<"undef all system defines">, - MarshallingInfoFlag<"PreprocessorOpts->UsePredefines", "true">, IsNegative; + MarshallingInfoNegativeFlag<"PreprocessorOpts->UsePredefines">; def include_pch : Separate<["-"], "include-pch">, Group, Flags<[CC1Option]>, HelpText<"Include precompiled header file">, MetaVarName<"">, @@ -1910,25 +1911,25 @@ def pch_through_hdrstop_create : Flag<["-"], "pch-through-hdrstop-create">, HelpText<"When creating a PCH, stop PCH generation after #pragma hdrstop.">, - MarshallingInfoFlag<"PreprocessorOpts->PCHWithHdrStopCreate", "false">; + MarshallingInfoFlag<"PreprocessorOpts->PCHWithHdrStopCreate">; def fno_validate_pch : Flag<["-"], "fno-validate-pch">, HelpText<"Disable validation of precompiled headers">, - MarshallingInfoFlag<"PreprocessorOpts->DisablePCHValidation", "false">; + MarshallingInfoFlag<"PreprocessorOpts->DisablePCHValidation">; def fallow_pch_with_errors : Flag<["-"], "fallow-pch-with-compiler-errors">, HelpText<"Accept a PCH file that was created with compiler errors">, - MarshallingInfoFlag<"PreprocessorOpts->AllowPCHWithCompilerErrors", "false">; + MarshallingInfoFlag<"PreprocessorOpts->AllowPCHWithCompilerErrors">; def dump_deserialized_pch_decls : Flag<["-"], "dump-deserialized-decls">, HelpText<"Dump declarations that are deserialized from PCH, for testing">, - MarshallingInfoFlag<"PreprocessorOpts->DumpDeserializedPCHDecls", "false">; + MarshallingInfoFlag<"PreprocessorOpts->DumpDeserializedPCHDecls">; def detailed_preprocessing_record : Flag<["-"], "detailed-preprocessing-record">, HelpText<"include a detailed record of preprocessing actions">, - MarshallingInfoFlag<"PreprocessorOpts->DetailedRecord", "false">; + MarshallingInfoFlag<"PreprocessorOpts->DetailedRecord">; def setup_static_analyzer : Flag<["-"], "setup-static-analyzer">, HelpText<"Set up preprocessor for static analyzer (done automatically when static analyzer is run).">, - MarshallingInfoFlag<"PreprocessorOpts->SetUpStaticAnalyzer", "false">; + MarshallingInfoFlag<"PreprocessorOpts->SetUpStaticAnalyzer">; def disable_pragma_debug_crash : Flag<["-"], "disable-pragma-debug-crash">, HelpText<"Disable any #pragma clang __debug that can lead to crashing behavior. This is meant for testing.">, - MarshallingInfoFlag<"PreprocessorOpts->DisablePragmaDebugCrash", "false">; + MarshallingInfoFlag<"PreprocessorOpts->DisablePragmaDebugCrash">; def pch_through_header_EQ : Joined<["-"], "pch-through-header=">, HelpText<"Stop PCH generation after including this file. When using a PCH, " @@ -1945,16 +1946,16 @@ def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group, HelpText<"Include comments from within macros in preprocessed output">, - MarshallingInfoFlag<"PreprocessorOutputOpts.ShowMacroComments", "false">; + MarshallingInfoFlag<"PreprocessorOutputOpts.ShowMacroComments">; def C : Flag<["-"], "C">, Flags<[CC1Option]>, Group, HelpText<"Include comments in preprocessed output">, - MarshallingInfoFlag<"PreprocessorOutputOpts.ShowComments", "false">; + MarshallingInfoFlag<"PreprocessorOutputOpts.ShowComments">; def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group, HelpText<"Disable linemarker output in -E mode">, - MarshallingInfoFlag<"PreprocessorOutputOpts.ShowLineMarkers", "true">, IsNegative; + MarshallingInfoNegativeFlag<"PreprocessorOutputOpts.ShowLineMarkers">; def dI : Flag<["-"], "dI">, Group, Flags<[CC1Option]>, HelpText<"Print include directives in -E mode in addition to normal output">, - MarshallingInfoFlag<"PreprocessorOutputOpts.ShowIncludeDirectives", "false">; + MarshallingInfoFlag<"PreprocessorOutputOpts.ShowIncludeDirectives">; defm rewrite_imports : OptInFFlag<"rewrite-imports", "", "", "", [], "PreprocessorOutputOpts.RewriteImports">; defm rewrite_includes : OptInFFlag<"rewrite-includes", "", "", "", [], "PreprocessorOutputOpts.RewriteIncludes">; defm use_line_directives : OptInFFlag<"use-line-directives", "Use #line in preprocessed output", @@ -4409,7 +4410,7 @@ def analysis_UnoptimizedCFG : Flag<["-"], "unoptimized-cfg">, HelpText<"Generate unoptimized CFGs for all analyses">, - MarshallingInfoFlag<"AnalyzerOpts->UnoptimizedCFG", "false">; + MarshallingInfoFlag<"AnalyzerOpts->UnoptimizedCFG">; def analysis_CFGAddImplicitDtors : Flag<["-"], "cfg-add-implicit-dtors">, HelpText<"Add C++ implicit destructors to CFGs for all analyses">; @@ -4433,23 +4434,23 @@ def analyzer_opt_analyze_headers : Flag<["-"], "analyzer-opt-analyze-headers">, HelpText<"Force the static analyzer to analyze functions defined in header files">, - MarshallingInfoFlag<"AnalyzerOpts->AnalyzeAll", "false">; + MarshallingInfoFlag<"AnalyzerOpts->AnalyzeAll">; def analyzer_opt_analyze_nested_blocks : Flag<["-"], "analyzer-opt-analyze-nested-blocks">, HelpText<"Analyze the definitions of blocks in addition to functions">, - MarshallingInfoFlag<"AnalyzerOpts->AnalyzeNestedBlocks", "false">; + MarshallingInfoFlag<"AnalyzerOpts->AnalyzeNestedBlocks">; def analyzer_display_progress : Flag<["-"], "analyzer-display-progress">, HelpText<"Emit verbose output about the analyzer's progress">, - MarshallingInfoFlag<"AnalyzerOpts->AnalyzerDisplayProgress", "false">; + MarshallingInfoFlag<"AnalyzerOpts->AnalyzerDisplayProgress">; def analyze_function : Separate<["-"], "analyze-function">, HelpText<"Run analysis on specific function (for C++ include parameters in name)">, MarshallingInfoString<"AnalyzerOpts->AnalyzeSpecificFunction">; def analyze_function_EQ : Joined<["-"], "analyze-function=">, Alias; def trim_egraph : Flag<["-"], "trim-egraph">, HelpText<"Only show error-related paths in the analysis graph">, - MarshallingInfoFlag<"AnalyzerOpts->TrimGraph", "false">; + MarshallingInfoFlag<"AnalyzerOpts->TrimGraph">; def analyzer_viz_egraph_graphviz : Flag<["-"], "analyzer-viz-egraph-graphviz">, HelpText<"Display exploded graph using GraphViz">, - MarshallingInfoFlag<"AnalyzerOpts->visualizeExplodedGraphWithGraphViz", "false">; + MarshallingInfoFlag<"AnalyzerOpts->visualizeExplodedGraphWithGraphViz">; def analyzer_dump_egraph : Separate<["-"], "analyzer-dump-egraph">, HelpText<"Dump exploded graph to the specified file">, MarshallingInfoString<"AnalyzerOpts->DumpExplodedGraphTo">; @@ -4467,14 +4468,14 @@ def analyzer_disable_retry_exhausted : Flag<["-"], "analyzer-disable-retry-exhausted">, HelpText<"Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)">, - MarshallingInfoFlag<"AnalyzerOpts->NoRetryExhausted", "false">; + MarshallingInfoFlag<"AnalyzerOpts->NoRetryExhausted">; def analyzer_max_loop : Separate<["-"], "analyzer-max-loop">, HelpText<"The maximum number of times the analyzer will go through a loop">, MarshallingInfoStringInt<"AnalyzerOpts->maxBlockVisitOnPath", "4">; def analyzer_stats : Flag<["-"], "analyzer-stats">, HelpText<"Print internal analyzer statistics.">, - MarshallingInfoFlag<"AnalyzerOpts->PrintStats", "false">; + MarshallingInfoFlag<"AnalyzerOpts->PrintStats">; def analyzer_checker : Separate<["-"], "analyzer-checker">, HelpText<"Choose analyzer checkers to enable">, @@ -4500,49 +4501,49 @@ def analyzer_disable_all_checks : Flag<["-"], "analyzer-disable-all-checks">, HelpText<"Disable all static analyzer checks">, - MarshallingInfoFlag<"AnalyzerOpts->DisableAllCheckers", "false">; + MarshallingInfoFlag<"AnalyzerOpts->DisableAllCheckers">; def analyzer_checker_help : Flag<["-"], "analyzer-checker-help">, HelpText<"Display the list of analyzer checkers that are available">, - MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelp", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelp">; def analyzer_checker_help_alpha : Flag<["-"], "analyzer-checker-help-alpha">, HelpText<"Display the list of in development analyzer checkers. These " "are NOT considered safe, they are unstable and will emit incorrect " "reports. Enable ONLY FOR DEVELOPMENT purposes">, - MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpAlpha", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpAlpha">; def analyzer_checker_help_developer : Flag<["-"], "analyzer-checker-help-developer">, HelpText<"Display the list of developer-only checkers such as modeling " "and debug checkers">, - MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpDeveloper", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpDeveloper">; def analyzer_config_help : Flag<["-"], "analyzer-config-help">, HelpText<"Display the list of -analyzer-config options. These are meant for " "development purposes only!">, - MarshallingInfoFlag<"AnalyzerOpts->ShowConfigOptionsList", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowConfigOptionsList">; def analyzer_list_enabled_checkers : Flag<["-"], "analyzer-list-enabled-checkers">, HelpText<"Display the list of enabled analyzer checkers">, - MarshallingInfoFlag<"AnalyzerOpts->ShowEnabledCheckerList", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowEnabledCheckerList">; def analyzer_config : Separate<["-"], "analyzer-config">, HelpText<"Choose analyzer options to enable">; def analyzer_checker_option_help : Flag<["-"], "analyzer-checker-option-help">, HelpText<"Display the list of checker and package options">, - MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionList", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionList">; def analyzer_checker_option_help_alpha : Flag<["-"], "analyzer-checker-option-help-alpha">, HelpText<"Display the list of in development checker and package options. " "These are NOT considered safe, they are unstable and will emit " "incorrect reports. Enable ONLY FOR DEVELOPMENT purposes">, - MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionAlphaList", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionAlphaList">; def analyzer_checker_option_help_developer : Flag<["-"], "analyzer-checker-option-help-developer">, HelpText<"Display the list of checker and package options meant for " "development purposes only">, - MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionDeveloperList", "false">; + MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionDeveloperList">; def analyzer_config_compatibility_mode : Separate<["-"], "analyzer-config-compatibility-mode">, HelpText<"Don't emit errors on invalid analyzer-config inputs">; @@ -4552,18 +4553,18 @@ def analyzer_werror : Flag<["-"], "analyzer-werror">, HelpText<"Emit analyzer results as errors rather than warnings">, - MarshallingInfoFlag<"AnalyzerOpts->AnalyzerWerror", "false">; + MarshallingInfoFlag<"AnalyzerOpts->AnalyzerWerror">; //===----------------------------------------------------------------------===// // Migrator Options //===----------------------------------------------------------------------===// def migrator_no_nsalloc_error : Flag<["-"], "no-ns-alloc-error">, HelpText<"Do not error on use of NSAllocateCollectable/NSReallocateCollectable">, - MarshallingInfoFlag<"MigratorOpts.NoNSAllocReallocError", "false">; + MarshallingInfoFlag<"MigratorOpts.NoNSAllocReallocError">; def migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">, HelpText<"Do not remove finalize method in gc mode">, - MarshallingInfoFlag<"MigratorOpts.NoFinalizeRemoval", "false">; + MarshallingInfoFlag<"MigratorOpts.NoFinalizeRemoval">; //===----------------------------------------------------------------------===// // CodeGen Options diff --git a/llvm/include/llvm/Option/OptParser.td b/llvm/include/llvm/Option/OptParser.td --- a/llvm/include/llvm/Option/OptParser.td +++ b/llvm/include/llvm/Option/OptParser.td @@ -164,20 +164,26 @@ code Denormalizer = "denormalizeString"; } -class MarshallingInfoFlag - : MarshallingInfo { +class MarshallingInfoFlag + : MarshallingInfo { code Normalizer = "normalizeSimpleFlag"; code Denormalizer = "denormalizeSimpleFlag"; } -class MarshallingInfoBitfieldFlag : MarshallingInfoFlag { +class MarshallingInfoNegativeFlag + : MarshallingInfo { + code Normalizer = "normalizeSimpleNegativeFlag"; + code Denormalizer = "denormalizeSimpleFlag"; +} + +class MarshallingInfoBitfieldFlag : MarshallingInfo { code Normalizer = "(normalizeFlagToValue)"; code ValueMerger = "mergeMaskValue"; code ValueExtractor = "(extractMaskValue)"; } class MarshallingInfoBooleanFlag - : MarshallingInfoFlag { + : MarshallingInfo { bit ShouldAlwaysEmit = 1; string MarshallingInfoKind = "BooleanFlag"; code Normalizer = "normalizeBooleanFlag"; @@ -187,9 +193,7 @@ // Mixins for additional marshalling attributes. -class IsNegative { - code Normalizer = "normalizeSimpleNegativeFlag"; -} +class DefaultValue { code DefaultValue = defaultvalue; } class AlwaysEmit { bit ShouldAlwaysEmit = 1; } class Normalizer { code Normalizer = normalizer; } class Denormalizer { code Denormalizer = denormalizer; }