[clang][cli] Streamline MarhsallingInfoFlag description

[jansvoboda11]

Summary

This replaces the existing MarshallingInfoFlag<...>, IsNegative with simpler MarshallingInfoNegativeFlag.

[jansvoboda11]

Taking over this patch, as Daniel is no longer involved.

[jansvoboda11]

Rebase, remove DefaultValue to avoid confusion with Default used for BoolOptionBase.

[dexonsmith]

LGTM.

clang/include/clang/Driver/Options.td

 
 // A boolean option which is opt-in in CC1. The positive option exists in CC1 and
 // Args.hasArg(OPT_ffoo) is used to check that the flag is enabled.
 // This is useful if the option is usually disabled.
 multiclass OptInFFlag<string name, string pos_prefix, string neg_prefix="",
                       string help="", list<OptionFlag> flags=[], code keypath=""> {
   def f#NAME : Flag<["-"], "f"#name>, Flags<!listconcat([CC1Option], flags)>,
                Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>,
-               MarshallingInfoFlag<keypath, "false">;
+               MarshallingInfoFlag<keypath>;
   def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<flags>,
                Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>;
 }
 
 // A boolean option which is opt-out in CC1. The negative option exists in CC1 and
 // Args.hasArg(OPT_fno_foo) is used to check that the flag is disabled.
 multiclass OptOutFFlag<string name, string pos_prefix, string neg_prefix,
                        string help="", list<OptionFlag> flags=[], code keypath=""> {
   def f#NAME : Flag<["-"], "f"#name>, Flags<flags>,
                Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>;
   def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<!listconcat([CC1Option], flags)>,
                Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>,
-               MarshallingInfoFlag<keypath, "false">;
+               MarshallingInfoFlag<keypath>;
 }
 
 multiclass BooleanMarshalledFFlag<string name, code keypath, code default_value, string pos_help = "", string neg_help=""> {
   def fno_#NAME : Flag<["-"], "fno-"#name>, HelpText<neg_help>;
   def f#NAME : Flag<["-"], "f"#name>, HelpText<pos_help>,
     MarshallingInfoBooleanFlag<keypath, default_value, !cast<Option>("fno_"#NAME)>;
 }
 
def ccc_objcmt_migrate : Separate<["-"], "ccc-objcmt-migrate">,
    "modern ObjC syntax">;
 
 // Make sure all other -ccc- options are rejected.
 def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>;
 
 // Comment Options
 
 def fparse_all_comments : Flag<["-"], "fparse-all-comments">, Group<f_clang_Group>, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"LangOpts->CommentOpts.ParseAllComments", "false">;
+  MarshallingInfoFlag<"LangOpts->CommentOpts.ParseAllComments">;
 
 // Filesystem Options FileSystemOpts
 
 def working_directory : JoinedOrSeparate<["-"], "working-directory">, Flags<[CC1Option]>,
   HelpText<"Resolve file paths relative to the specified directory">,
   MarshallingInfoString<"FileSystemOpts.WorkingDir">;
 def working_directory_EQ : Joined<["-"], "working-directory=">, Flags<[CC1Option]>,
   Alias<working_directory>;
 
 // Dependency Output Options
 
 def MV : Flag<["-"], "MV">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Use NMake/Jom format for the depfile">,
-    MarshallingInfoFlag<"DependencyOutputOpts.OutputFormat", "DependencyOutputFormat::Make">,
+    MarshallingInfoFlag<"DependencyOutputOpts.OutputFormat">,
+    DefaultValue<"DependencyOutputFormat::Make">,
     Normalizer<"(normalizeFlagToValue<DependencyOutputFormat, DependencyOutputFormat::NMake>)">;
 def H : Flag<["-"], "H">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
     HelpText<"Show header includes and nesting depth">,
-    MarshallingInfoFlag<"DependencyOutputOpts.ShowHeaderIncludes", "false">;
+    MarshallingInfoFlag<"DependencyOutputOpts.ShowHeaderIncludes">;
 def MG : Flag<["-"], "MG">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Add missing headers to depfile">,
-    MarshallingInfoFlag<"DependencyOutputOpts.AddMissingHeaderDeps", "false">;
+    MarshallingInfoFlag<"DependencyOutputOpts.AddMissingHeaderDeps">;
 def MP : Flag<["-"], "MP">, Group<M_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">,
   MarshallingInfoString<"DependencyOutputOpts.OutputFile">;
 def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
   HelpText<"Filename to write DOT-formatted header dependencies to">,
   MarshallingInfoString<"DependencyOutputOpts.DOTOutputFile">;
 def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
   Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">,
   MarshallingInfoString<"DependencyOutputOpts.ModuleDependencyOutputDir">;
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 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">,
   MarshallingInfoString<"DependencyOutputOpts.HeaderIncludeOutputFile">;
 
 } // Flags = [CC1Option, NoDriverOption]
 
 // Diagnostic Options
 
 let IsDiagnosticsArg = 1 in {
 
 def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits">, Group<f_clang_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<f_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<f_clang_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<f_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<f_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<f_Group>,
   Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">,
-  MarshallingInfoFlag<"AbsolutePath", "false">;
+  MarshallingInfoFlag<"AbsolutePath">;
 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"PedanticErrors", "false">;
+  MarshallingInfoFlag<"PedanticErrors">;
 def pedantic : Flag<["-", "--"], "pedantic">, Group<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<f_Group>;
 def fno_caret_diagnostics : Flag<["-"], "fno-caret-diagnostics">, Flags<[CC1Option]>,
-  Group<f_Group>, MarshallingInfoFlag<"ShowCarets", "true">, IsNegative;
+  Group<f_Group>, MarshallingInfoNegativeFlag<"ShowCarets">;
 def fshow_column : Flag<["-"], "fshow-column">, Group<f_Group>;
 def fno_show_column : Flag<["-"], "fno-show-column">, Flags<[CC1Option]>,
              Group<f_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<f_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<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">,
-  MarshallingInfoFlag<"ShowLocation", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"ShowLocation">;
 def fdiagnostics_show_option : Flag<["-"], "fdiagnostics-show-option">, Group<f_Group>,
     HelpText<"Print option name with mappable diagnostics">;
 def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group<f_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<f_Group>, Flags<[CC1Option]>;
 
 def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Which overload candidates to show when overload resolution fails: "
            "best|all; defaults to all">, Values<"best,all">,
   MarshallingInfoString<"ShowOverloads", "Ovl_All">,
   NormalizedValues<["Ovl_Best", "Ovl_All"]>, AutoNormalizeEnum;
 def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Format message diagnostics so that they fit within N columns">,
   MarshallingInfoStringInt<"MessageLength">;
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 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">,
   MarshallingInfoString<"DiagnosticLogFile">;
 def diagnostic_serialized_file : Separate<["-"], "serialize-diagnostic-file">,
   MetaVarName<"<filename>">,
   HelpText<"File for serializing diagnostics in a binary format">,
   MarshallingInfoString<"DiagnosticSerializationFile">;

 } // Flags = [CC1Option, NoDriverOption]
 
 } // IsDiagnoticsArg = 1
 
 // Frontend Options
 
 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">;
 def objcmt_migrate_subscripting : Flag<["-"], "objcmt-migrate-subscripting">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC subscripting">,
   MarshallingInfoBitfieldFlag<"FrontendOpts.ObjCMTAction", "FrontendOptions::ObjCMT_Subscripting">;
 def objcmt_migrate_property : Flag<["-"], "objcmt-migrate-property">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC property">,

 def objcmt_ns_nonatomic_iosonly: Flag<["-"], "objcmt-ns-nonatomic-iosonly">, Flags<[CC1Option]>,
   HelpText<"Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute">,
   MarshallingInfoBitfieldFlag<"FrontendOpts.ObjCMTAction", "FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty">;
 def objcmt_migrate_designated_init : Flag<["-"], "objcmt-migrate-designated-init">, Flags<[CC1Option]>,
   HelpText<"Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods">,
   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<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;
+  MarshallingInfoNegativeFlag<"FrontendOpts.UseTemporary">;
 def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"FrontendOpts.ShowTimers", "false">;
+  MarshallingInfoFlag<"FrontendOpts.ShowTimers">;
 def ftime_trace : Flag<["-"], "ftime-trace">, Group<f_Group>,
   HelpText<"Turn on time profiler. Generates JSON file based on output filename.">,
   DocBrief<[{
 Turn on time profiler. Generates JSON file based on output filename. Results
 can be analyzed with chrome://tracing or `Speedscope App
 <https://www.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<CompileOnly_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 <file>">, MetaVarName<"<file>">,
   MarshallingInfoString<"FrontendOpts.OutputFile">;
 def ftime_trace_granularity_EQ : Joined<["-"], "ftime-trace-granularity=">, Group<f_Group>,
   HelpText<"Minimum time granularity (in microseconds) traced by time profiler">,
   Flags<[CC1Option, CoreOption]>,
   MarshallingInfoStringInt<"FrontendOpts.TimeTraceGranularity", "500u">;
 def arcmt_migrate_report_output : Separate<["-"], "arcmt-migrate-report-output">,
   HelpText<"Output path for the plist report">,  Flags<[CC1Option]>,
   MarshallingInfoString<"FrontendOpts.ARCMTMigrateReportOut">;
 def objcmt_whitelist_dir_path: Joined<["-"], "objcmt-whitelist-dir-path=">, Flags<[CC1Option]>,
   HelpText<"Only modify files with a filename contained in the provided directory path">,
   MarshallingInfoString<"FrontendOpts.ObjCMTWhiteListPath">;
 // The misspelt "white-list" [sic] alias is due for removal.
 def : Joined<["-"], "objcmt-white-list-dir-path=">, Flags<[CC1Option]>,
     Alias<objcmt_whitelist_dir_path>;
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 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<Action_Group>,
   HelpText<"Include declaration types in AST dumps">,
-  MarshallingInfoFlag<"FrontendOpts.ASTDumpDeclTypes", "false">;
+  MarshallingInfoFlag<"FrontendOpts.ASTDumpDeclTypes">;
 def ast_dump_lookups : Flag<["-"], "ast-dump-lookups">,
   Group<Action_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">,
   NormalizedValues<["ARCMT_Check", "ARCMT_Modify", "ARCMT_Migrate"]>,
   MarshallingInfoString<"FrontendOpts.ARCMTAction", "ARCMT_None">,
   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<"<dump_filter>">,
   HelpText<"Use with -ast-dump or -ast-print to dump/print only AST declaration"
            " nodes having a certain substring in a qualified name. Use"
            " -ast-list to list all filterable declaration node names.">,
   MarshallingInfoString<"FrontendOpts.ASTDumpFilter">;
 def aux_triple : Separate<["-"], "aux-triple">,
def foverride_record_layout_EQ : Joined<["-"], "foverride-record-layout=">,
   MarshallingInfoString<"FrontendOpts.OverrideRecordLayoutsFile">;
 
 } // Flags = [CC1Option, NoDriverOption]
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
 def version : Flag<["-"], "version">,
   HelpText<"Print the compiler version">,
-  MarshallingInfoFlag<"FrontendOpts.ShowVersion", "false">;
+  MarshallingInfoFlag<"FrontendOpts.ShowVersion">;
 
 } // Flags = [CC1Option, CC1AsOption, NoDriverOption]
 
 // Target Options
 
 defm cuda_short_ptr : BooleanMarshalledFFlag<"cuda-short-ptr", "TargetOpts->NVPTXUseShortPointers", "false",
   "Use 32-bit pointers for accessing const/local/shared address spaces">;
 defm force_enable_int128 : OptInFFlag<"force-enable-int128", "Enable", "Disable", " support for int128_t type", [], "TargetOpts->ForceEnableInt128">;

 
 def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>,
   HelpText<"Do not emit metadata containing compiler name and version">;
 def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>,
   HelpText<"Emit metadata containing compiler name and version">,
   MarshallingInfoBooleanFlag<"CodeGenOpts.EmitVersionIdentMetadata", "true", Qn>;
 def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<opencl_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<opencl_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<opencl_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<opencl_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<f_Group>;
 def fno_autolink : Flag<["-"], "fno-autolink">, Flags<[CC1Option]>, Group<f_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<f_Group>, Flags<[DriverOption, 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}]>,
-   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",
   "Generate coverage mapping to enable code coverage analysis", "Disable code coverage analysis", "",
   [CoreOption], "CodeGenOpts.CoverageMapping">;
 defm addrsig : OptInFFlag<"addrsig", "Emit", "Don't emit", " an address-significance table", [CoreOption], "CodeGenOpts.Addrsig">;
 def fcommon : Flag<["-"], "fcommon">, Group<f_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">;
 defm keep_static_consts : OptInFFlag<"keep-static-consts", "Keep", "Don't keep", " static const variables if unused",
   [DriverOption], "CodeGenOpts.KeepStaticConsts">;
 defm jump_tables : OptOutFFlag<"jump-tables", "Use", "Do not use", " jump tables for lowering switches", [], "CodeGenOpts.NoUseJumpTables">;
 
 let Flags = [CC1Option, CoreOption] in {
def fsanitize_address_use_after_scope : Flag<["-"], "fsanitize-address-use-after-scope">,
   MarshallingInfoBooleanFlag<"CodeGenOpts.SanitizeAddressUseAfterScope", "false", fno_sanitize_address_use_after_scope>;                 
 defm sanitize_address_poison_custom_array_cookie : BooleanMarshalledFFlag<"sanitize-address-poison-custom-array-cookie",
   "CodeGenOpts.SanitizeAddressPoisonCustomArrayCookie", "false",
   "Enable poisoning array cookies when using custom operator new[] in AddressSanitizer",
   "Disable poisoning array cookies when using custom operator new[] in AddressSanitizer">,
   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">,
-  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<f_clang_Group>;
 def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">,
-  Group<f_clang_Group>, MarshallingInfoFlag<"CodeGenOpts.SanitizeMinimalRuntime", "false">;
+  Group<f_clang_Group>, MarshallingInfoFlag<"CodeGenOpts.SanitizeMinimalRuntime">;
 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.">,
-  MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCrossDso", "false">; 
+  MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCrossDso">; 
 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">,
-  MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiICallGeneralizePointers", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiICallGeneralizePointers">;
 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">,
-  MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCanonicalJumpTables", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCanonicalJumpTables">;
 def fsanitize_stats : Flag<["-"], "fsanitize-stats">,
   Group<f_clang_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<f_clang_Group>, HelpText<"Enable origins tracking in MemorySanitizer">,
   MarshallingInfoStringInt<"CodeGenOpts.SanitizeMemoryTrackOrigins">;
 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.">,
   MarshallingInfoStringInt<"CodeGenOpts.EmitCheckPathComponentsToStrip", "0", "int">;
 def fthin_link_bitcode_EQ : Joined<["-"], "fthin-link-bitcode=">,
   Group<f_Group>,
   HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">,
   MarshallingInfoString<"CodeGenOpts.ThinLinkBitcodeFile">;
 
 } // Flags = [CC1Option, CoreOption]
 
 def fstrict_float_cast_overflow : Flag<["-"], "fstrict-float-cast-overflow">, Group<f_Group>,
   HelpText<"Assume that overflowing float-to-int casts are undefined (default)">;
 def fno_strict_float_cast_overflow : Flag<["-"], "fno-strict-float-cast-overflow">, Group<f_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">;
 defm experimental_new_pass_manager : BooleanMarshalledFFlag<"experimental-new-pass-manager", "CodeGenOpts.ExperimentalNewPassManager",
   "static_cast<unsigned>(ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER)", "Enables an experimental new pass manager in LLVM.",
   "Disables an experimental new pass manager in LLVM.">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_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<f_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<f_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", "",
   "Omit function index section at the expense of single-function patching performance", "", [], "CodeGenOpts.XRayOmitFunctionIndex">;
 defm fine_grained_bitfield_accesses : BooleanMarshalledFFlag<"fine-grained-bitfield-accesses",
   "CodeGenOpts.FineGrainedBitfieldAccesses", "false",
   "Use separate accesses for consecutive bitfield runs with legal widths and alignments.",
   "Use large-integer access for consecutive bitfield runs.">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_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<f_Group>,
   HelpText<"Disallow merging of constants">;
 def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"CodeGenOpts.MSVolatile", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.MSVolatile">;
 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]>,
-  MarshallingInfoFlag<"CodeGenOpts.AssumeSaneOperatorNew", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"CodeGenOpts.AssumeSaneOperatorNew">;
 def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
 def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_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<f_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<f_Group>;
 def fno_objc_convert_messages_to_runtime_calls :
   Flag<["-"], "fno-objc-convert-messages-to-runtime-calls">, Group<f_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">;
 defm escaping_block_tail_calls : OptOutFFlag<"escaping-block-tail-calls", "", "", "", [], "CodeGenOpts.NoEscapingBlockTailCalls">;
 defm plt : OptOutFFlag<"plt", "",
   "Use GOT indirection instead of PLT to make external function calls (x86 only)", "", [], "CodeGenOpts.NoPLT">;
 def fpreserve_as_comments : Flag<["-"], "fpreserve-as-comments">, Group<f_Group>;
 def fno_preserve_as_comments : Flag<["-"], "fno-preserve-as-comments">, Flags<[CC1Option]>, Group<f_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<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable stack clash protection">,
-  MarshallingInfoFlag<"CodeGenOpts.StackClashProtector", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.StackClashProtector">;
 def fnostack_clash_protection : Flag<["-"], "fnostack-clash-protection">, Group<f_Group>,
   HelpText<"Disable stack clash protection">;
 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">,
-  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">;
 defm reroll_loops : OptInFFlag<"reroll-loops", "Turn on loop reroller", "", "", [], "CodeGenOpts.RerollLoops">;
 def fuse_init_array : Flag<["-"], "fuse-init-array">, Group<f_Group>;
 def fno_use_init_array : Flag<["-"], "fno-use-init-array">, Group<f_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",
   "Enables splitting of the LTO unit", "", "", [CoreOption], "CodeGenOpts.EnableSplitLTOUnit">;
 defm force_emit_vtables : OptInFFlag<"force-emit-vtables",
   "Emits more virtual tables to improve devirtualization", "", "", [CoreOption], "CodeGenOpts.ForceEmitVTables">;
 defm virtual_function_elimination : OptInFFlag<"virtual-function-elimination",
   "Enables dead virtual function elimination optimization. Requires -flto=full", "", "", [CoreOption], "CodeGenOpts.VirtualFunctionElimination">;
 defm zero_initialized_in_bss : OptOutFFlag<"zero-initialized-in-bss", "", "Don't place zero initialized data in BSS",
   "", [], "CodeGenOpts.NoZeroInitializedInBSS">;
 defm data_sections : OptInFFlag<"data-sections", "Place each data in its own section", "", "", [], "CodeGenOpts.DataSections">;
 defm stack_size_section : OptInFFlag<"stack-size-section", "Emit section containing metadata on function stack sizes",
   "", "", [], "CodeGenOpts.StackSizeSection">;
 defm unique_basic_block_section_names : OptInFFlag<"unique-basic-block-section-names",
  "Use unique names for basic block sections (ELF Only)", "", "", [], "CodeGenOpts.UniqueBasicBlockSectionNames">;
 defm unique_internal_linkage_names : OptInFFlag<"unique-internal-linkage-names",
  "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path", "", "", [], "CodeGenOpts.UniqueInternalLinkageNames">;
 def funique_section_names : Flag<["-"], "funique-section-names">, Group<f_Group>;
 def fno_unique_section_names : Flag<["-"], "fno-unique-section-names">, Group<f_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<f_Group>;
 def fno_strict_return : Flag<["-"], "fno-strict-return">, Group<f_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<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]>, 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<g_flags_Group>, Flags<[CoreOption, CC1Option]>,
-  MarshallingInfoFlag<"CodeGenOpts.DebugColumnInfo", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"CodeGenOpts.DebugColumnInfo">;
 def gembed_source : Flag<["-"], "gembed-source">, Group<g_flags_Group>, Flags<[CC1Option]>,
     HelpText<"Embed source text in DWARF debug sections">,
-    MarshallingInfoFlag<"CodeGenOpts.EmbedSource", "false">;
+    MarshallingInfoFlag<"CodeGenOpts.EmbedSource">;
 def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_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<m_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<m_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<m_Group>, Flags<[CoreOption,CC1Option]>,
-  MarshallingInfoFlag<"CodeGenOpts.SpeculativeLoadHardening", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.SpeculativeLoadHardening">;
 def ForceAAPCSBitfieldLoad : Flag<["-"], "fAAPCSBitfieldLoad">, Group<m_arm_Features_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<m_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<m_Group>, Flags<[DriverOption,CC1Option]>;
 def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_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<m_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<m_Group>, Flags<[CC1Option]>,
   HelpText<"Use software floating point">,
-  MarshallingInfoFlag<"CodeGenOpts.SoftFloat", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.SoftFloat">;
 def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_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<m_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<m_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<m_Group>,
-  MarshallingInfoFlag<"CodeGenOpts.RecordMCount", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.RecordMCount">;
 def mpacked_stack : Flag<["-"], "mpacked-stack">, HelpText<"Use packed stack layout (SystemZ only).">,
   Flags<[CC1Option]>, Group<m_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=">,
     Group<f_Group>, Flags<[DriverOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">,
     HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">, Values<"off,all,bitcode,marker">,
     NormalizedValuesScope<"CodeGenOptions">,
     MarshallingInfoString<"CodeGenOpts.EmbedBitcode", "Embed_Off">,
     NormalizedValues<["Embed_Off", "Embed_All", "Embed_Bitcode", "Embed_Marker"]>, AutoNormalizeEnum;

 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.">,
   MarshallingInfoString<"CodeGenOpts.PreferVectorWidth">;
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
 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">,
   NormalizedValuesScope<"llvm::Reloc">,
   NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
   MarshallingInfoString<"CodeGenOpts.RelocationModel", "PIC_">,
   AutoNormalizeEnum;
 def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">,
def split_dwarf_output : Separate<["-"], "split-dwarf-output">,
   MarshallingInfoString<"CodeGenOpts.SplitDwarfOutput">;
 
 } // Flags = [CC1Option, CC1AsOption, NoDriverOption]
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 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<disable_llvm_passes>;
 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",
   "false", "Prints debug information for the new pass manager",
   "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">,
   HelpText<"Preserve order of LLVM use-lists when serializing">,
   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.">,
   MarshallingInfoString<"CodeGenOpts.CudaGpuBinaryFileName">;
 def mdebug_pass : Separate<["-"], "mdebug-pass">,
   HelpText<"Enable additional debug output">,
   MarshallingInfoString<"CodeGenOpts.DebugPass">;
 def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">,

 } // Flags = [CC1Option, NoDriverOption]
 
 // HeaderSearch Options
 
 def fmodules_validate_once_per_build_session : Flag<["-"], "fmodules-validate-once-per-build-session">,
   Group<i_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<i_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<i_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<i_Group>, Flags<[DriverOption]>;
 def fvalidate_ast_input_files_content:
   Flag <["-"], "fvalidate-ast-input-files-content">,
   Group<f_Group>, Flags<[CC1Option]>,
   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<f_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<i_Group>,
   Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
   HelpText<"Specify the module user build path">,
   MarshallingInfoString<"HeaderSearchOpts->ModuleUserBuildPath">;
 def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>,
   Flags<[CC1Option]>, MetaVarName<"<seconds>">,
   HelpText<"Specify the interval (in seconds) between attempts to prune the module cache">,
def resource_dir : Separate<["-"], "resource-dir">,
   HelpText<"The directory which holds the compiler resource files">,
   MarshallingInfoString<"HeaderSearchOpts->ResourceDir">;
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 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>">,
-  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. "
            "Supported options are 'raw' and 'obj'.">,
   MarshallingInfoString<"HeaderSearchOpts->ModuleFormat", [{std::string("raw")}]>;
 
 } // Flags = [CC1Option, NoDriverOption]
 
 // Language Options
 
 def cl_single_precision_constant : Flag<["-"], "cl-single-precision-constant">, Group<opencl_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<opencl_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<f_Group>;
 def fno_access_control : Flag<["-"], "fno-access-control">, Group<f_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<f_clang_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<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">;
 def fgnu_inline_asm : Flag<["-"], "fgnu-inline-asm">, Group<f_Group>;
 def fno_gnu_inline_asm : Flag<["-"], "fno-gnu-inline-asm">, Group<f_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<f_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<f_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<f_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<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use DWARF style exceptions">,
-  MarshallingInfoFlag<"LangOpts->DWARFExceptions", "false">;
+  MarshallingInfoFlag<"LangOpts->DWARFExceptions">;
 def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use SjLj style exceptions">,
-  MarshallingInfoFlag<"LangOpts->SjLjExceptions", "false">;
+  MarshallingInfoFlag<"LangOpts->SjLjExceptions">;
 def fseh_exceptions : Flag<["-"], "fseh-exceptions">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use SEH style exceptions">,
-  MarshallingInfoFlag<"LangOpts->SEHExceptions", "false">;
+  MarshallingInfoFlag<"LangOpts->SEHExceptions">;
 def fwasm_exceptions : Flag<["-"], "fwasm-exceptions">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use WebAssembly style exceptions">,
-  MarshallingInfoFlag<"LangOpts->WasmExceptions", "false">;
+  MarshallingInfoFlag<"LangOpts->WasmExceptions">;
 def fignore_exceptions : Flag<["-"], "fignore-exceptions">, Group<f_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<f_Group>;
 def fno_cxx_static_destructors : Flag<["-"], "fno-c++-static-destructors">, Group<f_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<f_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<f_Group>, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"LangOpts->FPRoundingMode", "llvm::RoundingMode::NearestTiesToEven">,
+  MarshallingInfoFlag<"LangOpts->FPRoundingMode">, DefaultValue<"llvm::RoundingMode::NearestTiesToEven">,
   Normalizer<"(normalizeFlagToValue<llvm::RoundingMode, llvm::RoundingMode::Dynamic>)">;
 def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>, Flags<[CC1Option]>;
 def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_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<f_clang_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">;
 defm xray_always_emit_typedevents : OptInFFlag<"xray-always-emit-typedevents",
   "Always emit __xray_typedevent(...) calls even if the containing function is not always instrumented", "", "", [], "LangOpts->XRayAlwaysEmitTypedEvents">;
 defm experimental_relative_cxx_abi_vtables : BooleanMarshalledFFlag<"experimental-relative-c++-abi-vtables",
   "LangOpts->RelativeCXXABIVTables", "false",
   "Use the experimental C++ class ABI for classes with virtual tables",
   "Do not use the experimental C++ class ABI for classes with virtual tables">, Group<f_Group>, Flags<[CC1Option]>;
 def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_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">;
 defm pch_instantiate_templates : OptInFFlag<"pch-instantiate-templates", "Instantiate templates already while building a PCH",
   "", "", [], "LangOpts->PCHInstantiateTemplates">;
 def fmodules_ts : Flag <["-"], "fmodules-ts">, Group<f_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<f_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<f_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<f_Group>;
 def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>,
   HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"LangOpts->ElideConstructors", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->ElideConstructors">;
 def fimplicit_modules : Flag <["-"], "fimplicit-modules">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_implicit_modules :
   Flag <["-"], "fno-implicit-modules">,
   Group<f_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",
   "", "", [], "LangOpts->ObjCExceptions">;
 defm application_extension : OptInFFlag<"application-extension", "Restrict code to those available for App Extensions",
   "", "", [], "LangOpts->AppExt">;
 defm relaxed_template_template_args : OptInFFlag<"relaxed-template-template-args",
   "Enable C++17 relaxed template template argument matching", "", "", [], "LangOpts->RelaxedTemplateTemplateArgs">;
 defm sized_deallocation : OptInFFlag<"sized-deallocation", "Enable C++14 sized gloval deallocation functions",
   "", "", [], "LangOpts->SizedDeallocation">;
 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]>, MarshallingInfoFlag<"LangOpts->ObjCInferRelatedResultType", "true">, IsNegative;
+  Flags<[CC1Option]>, MarshallingInfoNegativeFlag<"LangOpts->ObjCInferRelatedResultType">;
 def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
   HelpText<"Parse OpenMP pragmas and generate parallel code.">,
-  MarshallingInfoFlag<"LangOpts->OpenMP", "0u">, Normalizer<"(normalizeFlagToValue<unsigned, 50u>)">;
+  MarshallingInfoFlag<"LangOpts->OpenMP">, DefaultValue<"0u">, Normalizer<"(normalizeFlagToValue<unsigned, 50u>)">;
 def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;
 defm openmp_optimistic_collapse : OptInFFlag<"openmp-optimistic-collapse", "", "", "",
   [NoArgumentUnused, HelpHidden], "LangOpts->OpenMPOptimisticCollapse">;
 defm pascal_strings : OptInFFlag<"pascal-strings", "Recognize and construct Pascal-style string literals",
   "", "", [], "LangOpts->PascalStrings">;
 defm ropi : OptInFFlag<"ropi", "Generate read-only position independent code (ARM only)", "", "", [], "LangOpts->ROPI">;
 defm rwpi : OptInFFlag<"rwpi", "Generate read-write position independent code (ARM only)", "", "", [], "LangOpts->RWPI" >;
 defm short_enums : OptInFFlag<"short-enums",
   "Allocate to an enum type only as many bytes as it needs for the declared range of possible values",
   "", "", [], "LangOpts->ShortEnums">;
 def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>;
 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Disable spell-checking">,
-  MarshallingInfoFlag<"LangOpts->SpellChecking", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->SpellChecking">;
 def fthreadsafe_statics : Flag<["-"], "fthreadsafe-statics">, Group<f_Group>;
 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">,
-  MarshallingInfoFlag<"LangOpts->ThreadsafeStatics", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->ThreadsafeStatics">;
 def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_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<f_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<f_Group>, Flags<[CC1Option]>,
   HelpText<"Store string literals as writable data">,
-  MarshallingInfoFlag<"LangOpts->WritableStrings", "false">;
+  MarshallingInfoFlag<"LangOpts->WritableStrings">;
 def fenable_matrix : Flag<["-"], "fenable-matrix">, Group<f_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<m_Group>, Flags<[DriverOption,CC1Option]>,
   HelpText<"Enable hexagon-qdsp6 backward compatibility">,
-  MarshallingInfoFlag<"LangOpts->HexagonQdsp6Compat", "false">;
+  MarshallingInfoFlag<"LangOpts->HexagonQdsp6Compat">;
 def malign_double : Flag<["-"], "malign-double">, Group<m_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<m_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<m_arm_Features_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<f_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<f_Group>, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"LangOpts->ExplicitNoSemanticInterposition", "false">;
+  MarshallingInfoFlag<"LangOpts->ExplicitNoSemanticInterposition">;
 def fsycl : Flag<["-"], "fsycl">, Group<sycl_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<sycl_Group>, Flags<[CoreOption]>,
   HelpText<"Disable SYCL kernels compilation for device">;
 
 def fmax_tokens_EQ : Joined<["-"], "fmax-tokens=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Max total number of preprocessed tokens for -Wmax-tokens.">,
   MarshallingInfoStringInt<"LangOpts->MaxTokens">;
 def fcf_runtime_abi_EQ : Joined<["-"], "fcf-runtime-abi=">, Group<f_Group>,
     Flags<[CC1Option]>, Values<"unspecified,standalone,objc,swift,swift-5.0,swift-4.2,swift-4.1">,
def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>,
   MarshallingInfoString<"LangOpts->SYCLVersion", "0">,
   NormalizedValues<["2017", "2017", "2017", "2017"]>, AutoNormalizeEnum,
   ShouldParseIf<"LangOpts->SYCL">;
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
 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]
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 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<"<class name>">,
   HelpText<"Specify the class to use for constant Objective-C string objects.">,
   MarshallingInfoString<"LangOpts->ObjCConstantStringClass">;
 def pic_level : Separate<["-"], "pic-level">,
   HelpText<"Value for __PIC__">,
   MarshallingInfoStringInt<"LangOpts->PICLevel">;
def fsanitize_address_field_padding : Joined<["-"], "fsanitize-address-field-padding=">,
   MarshallingInfoStringInt<"LangOpts->SanitizeAddressFieldPadding">;
 
 } // Flags = [CC1Option,CoreOption]
 
 // Preprocessor Options
 
 def undef : Flag<["-"], "undef">, Group<u_Group>, Flags<[CC1Option]>,
   HelpText<"undef all system defines">,
-  MarshallingInfoFlag<"PreprocessorOpts->UsePredefines", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"PreprocessorOpts->UsePredefines">;
 
 def include_pch : Separate<["-"], "include-pch">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Include precompiled header file">, MetaVarName<"<file>">,
   MarshallingInfoString<"PreprocessorOpts->ImplicitPCHInclude">;
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 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, "
            "skip tokens until after this file is included.">,
   MarshallingInfoString<"PreprocessorOpts->PCHThroughHeader">;
 def fobjc_arc_cxxlib_EQ : Joined<["-"], "fobjc-arc-cxxlib=">,
   HelpText<"Objective-C++ Automatic Reference Counting standard library kind">, Values<"libc++,libstdc++,none">,
   MarshallingInfoString<"PreprocessorOpts->ObjCXXARCStandardLibrary", "ARCXX_nolib">,
   NormalizedValues<["ARCXX_libcxx", "ARCXX_libstdcxx", "ARCXX_nolib"]>, AutoNormalizeEnum; 
 
 } // Flags = [CC1Option, NoDriverOption]
 
 // Preprocessor Output Options
 
 def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
     HelpText<"Include comments from within macros in preprocessed output">,
-    MarshallingInfoFlag<"PreprocessorOutputOpts.ShowMacroComments", "false">; 
+    MarshallingInfoFlag<"PreprocessorOutputOpts.ShowMacroComments">; 
 def C : Flag<["-"], "C">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
     HelpText<"Include comments in preprocessed output">,
-    MarshallingInfoFlag<"PreprocessorOutputOpts.ShowComments", "false">;
+    MarshallingInfoFlag<"PreprocessorOutputOpts.ShowComments">;
 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 dI : Flag<["-"], "dI">, Group<d_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",
   "", "", [], "PreprocessorOutputOpts.UseLineDirectives">;
 
 // Standard Options
 
 def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>,

 def fno_padding_on_unsigned_fixed_point : Flag<["-"], "fno-padding-on-unsigned-fixed-point">;
 
 //===----------------------------------------------------------------------===//
 // Analyzer Options
 //===----------------------------------------------------------------------===//
 
 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">;
 
 def analyzer_store : Separate<["-"], "analyzer-store">,
   HelpText<"Source Code Analysis - Abstract Memory Store Models">;
 def analyzer_store_EQ : Joined<["-"], "analyzer-store=">, Alias<analyzer_store>;
 
 def analyzer_constraints : Separate<["-"], "analyzer-constraints">,
   HelpText<"Source Code Analysis - Symbolic Constraint Engines">;
 def analyzer_constraints_EQ : Joined<["-"], "analyzer-constraints=">,
   Alias<analyzer_constraints>;
 
 def analyzer_output : Separate<["-"], "analyzer-output">,
   HelpText<"Source Code Analysis - Output Options">;
 def analyzer_output_EQ : Joined<["-"], "analyzer-output=">,
   Alias<analyzer_output>;
 
 def analyzer_purge : Separate<["-"], "analyzer-purge">,
   HelpText<"Source Code Analysis - Dead Symbol Removal Frequency">;
 def analyzer_purge_EQ : Joined<["-"], "analyzer-purge=">, Alias<analyzer_purge>;
 
 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<analyze_function>;
 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">;
 def analyzer_dump_egraph_EQ : Joined<["-"], "analyzer-dump-egraph=">, Alias<analyzer_dump_egraph>;
 
 def analyzer_inline_max_stack_depth : Separate<["-"], "analyzer-inline-max-stack-depth">,
   HelpText<"Bound on stack depth while inlining (4 by default)">,
   MarshallingInfoStringInt<"AnalyzerOpts->InlineMaxStackDepth", "5">;
 def analyzer_inline_max_stack_depth_EQ : Joined<["-"], "analyzer-inline-max-stack-depth=">,
   Alias<analyzer_inline_max_stack_depth>;
 
 def analyzer_inlining_mode : Separate<["-"], "analyzer-inlining-mode">,
   HelpText<"Specify the function selection heuristic used during inlining">;
 def analyzer_inlining_mode_EQ : Joined<["-"], "analyzer-inlining-mode=">, Alias<analyzer_inlining_mode>;
 
 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">,
   ValuesCode<[{
     const char *Values =
     #define GET_CHECKERS
     #define CHECKER(FULLNAME, CLASS, HT, DOC_URI, IS_HIDDEN)  FULLNAME ","
     #include "clang/StaticAnalyzer/Checkers/Checkers.inc"

 
 def analyzer_disable_checker : Separate<["-"], "analyzer-disable-checker">,
   HelpText<"Choose analyzer checkers to disable">;
 def analyzer_disable_checker_EQ : Joined<["-"], "analyzer-disable-checker=">,
   Alias<analyzer_disable_checker>;
 
 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">;
 
 def analyzer_config_compatibility_mode_EQ : Joined<["-"], "analyzer-config-compatibility-mode=">,
   Alias<analyzer_config_compatibility_mode>;
 
 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
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 def default_function_attr : Separate<["-"], "default-function-attr">,
   HelpText<"Apply given attribute to all functions">;

llvm/include/llvm/Option/OptParser.td

 }
 
 class MarshallingInfoStringInt<code keypath, code defaultvalue="0", code type="unsigned">
   : MarshallingInfo<keypath, defaultvalue> {
   code Normalizer = "normalizeStringIntegral<"#type#">";
   code Denormalizer = "denormalizeString";
 }
 
-class MarshallingInfoFlag<code keypath, code defaultvalue>
-  : MarshallingInfo<keypath, defaultvalue> {
+class MarshallingInfoFlag<code keypath>
+  : MarshallingInfo<keypath, "false"> {
   code Normalizer = "normalizeSimpleFlag";
   code Denormalizer = "denormalizeSimpleFlag";
 }
 
-class MarshallingInfoBitfieldFlag<code keypath, code value> : MarshallingInfoFlag<keypath, "0u"> {
+class MarshallingInfoNegativeFlag<code keypath>
+  : MarshallingInfo<keypath, "true"> {
+  code Normalizer = "normalizeSimpleNegativeFlag";
+  code Denormalizer = "denormalizeSimpleFlag";
+}
+
+class MarshallingInfoBitfieldFlag<code keypath, code value> : MarshallingInfo<keypath, "0u"> {
   code Normalizer = "(normalizeFlagToValue<unsigned, "#value#">)";
   code ValueMerger = "mergeMaskValue";
   code ValueExtractor = "(extractMaskValue<unsigned, decltype("#value#"), "#value#">)";
 }
 
 class MarshallingInfoBooleanFlag<code keypath, code defaultvalue, Option negopt>
-  : MarshallingInfoFlag<keypath, defaultvalue> {
+  : MarshallingInfo<keypath, defaultvalue> {
   bit ShouldAlwaysEmit = 1;
   string MarshallingInfoKind = "BooleanFlag";
   code Normalizer = "normalizeBooleanFlag";
   code Denormalizer = "denormalizeBooleanFlag";
   Option NegOption = negopt;
 }
 
 // Mixins for additional marshalling attributes.
 
-class IsNegative {
-  code Normalizer = "normalizeSimpleNegativeFlag";
-}
+class DefaultValue<code defaultvalue> { code DefaultValue = defaultvalue; }
 class AlwaysEmit { bit ShouldAlwaysEmit = 1; }
 class Normalizer<code normalizer> { code Normalizer = normalizer; }
 class Denormalizer<code denormalizer> { code Denormalizer = denormalizer; }
 class NormalizedValuesScope<code scope> { code NormalizedValuesScope = scope; }
 class NormalizedValues<list<code> definitions> { list<code> NormalizedValues = definitions; } 
 class AutoNormalizeEnum {
   code Normalizer = "normalizeSimpleEnum";
   code Denormalizer = "denormalizeSimpleEnum";