dang created this revision.
dang added a reviewer: Bigcheese.
Herald added subscribers: llvm-commits, cfe-commits, sstefan1, dexonsmith, 
aheejin.
Herald added a reviewer: jdoerfert.
Herald added projects: clang, LLVM.

This replaces the existing `MarshallingInfoFlag` and `IsNegative` with simpler
`MarshalllingInfoFlag` and `MarshallingInfoNegativeFlag` mixins. This change
makes existing marshalling info specifications in Options.td easier to read.

Depends on D84674 <https://reviews.llvm.org/D84674>


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D84675

Files:
  clang/include/clang/Driver/Options.td
  llvm/include/llvm/Option/OptParser.td

Index: llvm/include/llvm/Option/OptParser.td
===================================================================
--- llvm/include/llvm/Option/OptParser.td
+++ llvm/include/llvm/Option/OptParser.td
@@ -164,20 +164,26 @@
   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";
@@ -187,9 +193,7 @@
 
 // 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; }
Index: clang/include/clang/Driver/Options.td
===================================================================
--- clang/include/clang/Driver/Options.td
+++ clang/include/clang/Driver/Options.td
@@ -233,7 +233,7 @@
                       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)>;
 }
@@ -246,7 +246,7 @@
                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=""> {
@@ -331,7 +331,7 @@
 // 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
 
@@ -345,17 +345,18 @@
 
 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">,
@@ -371,10 +372,10 @@
 
 def sys_header_deps : Flag<["-"], "sys-header-deps">,
   HelpText<"Include system headers in dependency output">,
-  MarshallingInfoFlag<"DependencyOutputOpts.IncludeSystemHeaders", "false">;
+  MarshallingInfoFlag<"DependencyOutputOpts.IncludeSystemHeaders">;
 def module_file_deps : Flag<["-"], "module-file-deps">,
   HelpText<"Include module files in dependency output">,
-  MarshallingInfoFlag<"DependencyOutputOpts.IncludeModuleFiles", "false">;
+  MarshallingInfoFlag<"DependencyOutputOpts.IncludeModuleFiles">;
 
 def header_include_file : Separate<["-"], "header-include-file">,
   HelpText<"Filename (or -) to write header include output to">,
@@ -388,49 +389,49 @@
 
 def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits">, Group<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]>;
@@ -448,10 +449,10 @@
 
 def fno_diagnostics_use_presumed_location : Flag<["-"], "fno-diagnostics-use-presumed-location">,
   HelpText<"Ignore #line directives when displaying diagnostic locations">,
-  MarshallingInfoFlag<"ShowPresumedLoc", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"ShowPresumedLoc">;
 def Wno_rewrite_macros : Flag<["-"], "Wno-rewrite-macros">,
   HelpText<"Silence ObjC rewriting warnings">,
-  MarshallingInfoFlag<"NoRewriteMacros", "false">;
+  MarshallingInfoFlag<"NoRewriteMacros">;
 
 def diagnostic_log_file : Separate<["-"], "diagnostic-log-file">,
   HelpText<"Filename (or -) to log diagnostics to">,
@@ -500,7 +501,7 @@
 
 def arcmt_migrate_emit_arc_errors : Flag<["-"], "arcmt-migrate-emit-errors">,
   HelpText<"Emit ARC errors even if the migrator can fix them">, Flags<[CC1Option]>,
-  MarshallingInfoFlag<"FrontendOpts.ARCMTMigrateEmitARCErrors", "false">;
+  MarshallingInfoFlag<"FrontendOpts.ARCMTMigrateEmitARCErrors">;
 def objcmt_migrate_literals : Flag<["-"], "objcmt-migrate-literals">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC literals">,
   MarshallingInfoBitfieldFlag<"FrontendOpts.ObjCMTAction", "FrontendOptions::ObjCMT_Literals">;
@@ -548,13 +549,13 @@
   MarshallingInfoBitfieldFlag<"FrontendOpts.ObjCMTAction", "FrontendOptions::ObjCMT_DesignatedInitializer">;
 def fsystem_module : Flag<["-"], "fsystem-module">, Flags<[CC1Option]>,
   HelpText<"Build this module as a system module. Only used with -emit-module">,
-  MarshallingInfoFlag<"FrontendOpts.IsSystemModule", "false">;
+  MarshallingInfoFlag<"FrontendOpts.IsSystemModule">;
 def fno_temp_file : Flag<["-"], "fno-temp-file">, Group<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<[{
@@ -562,18 +563,18 @@
 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>">,
@@ -596,40 +597,40 @@
 
 def code_completion_macros : Flag<["-"], "code-completion-macros">,
   HelpText<"Include macros in code-completion results">,
-  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeMacros", "false">;
+  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeMacros">;
 def code_completion_patterns : Flag<["-"], "code-completion-patterns">,
   HelpText<"Include code patterns in code-completion results">,
-  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeCodePatterns", "false">;
+  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeCodePatterns">;
 def no_code_completion_globals : Flag<["-"], "no-code-completion-globals">,
   HelpText<"Do not include global declarations in code-completion results.">,
-  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeGlobals", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"FrontendOpts.CodeCompleteOpts.IncludeGlobals">;
 def no_code_completion_ns_level_decls : Flag<["-"], "no-code-completion-ns-level-decls">,
   HelpText<"Do not include declarations inside namespaces (incl. global namespace) in the code-completion results.">,
-  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeNamespaceLevelDecls", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"FrontendOpts.CodeCompleteOpts.IncludeNamespaceLevelDecls">;
 def code_completion_brief_comments : Flag<["-"], "code-completion-brief-comments">,
   HelpText<"Include brief documentation comments in code-completion results.">,
-  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeBriefComments", "false">;
+  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeBriefComments">;
 def code_completion_with_fixits : Flag<["-"], "code-completion-with-fixits">,
   HelpText<"Include code completion results which require small fix-its.">,
-  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeFixIts", "false">;
+  MarshallingInfoFlag<"FrontendOpts.CodeCompleteOpts.IncludeFixIts">;
 def disable_free : Flag<["-"], "disable-free">,
   HelpText<"Disable freeing of memory on exit">,
-  MarshallingInfoFlag<"FrontendOpts.DisableFree", "false">;
+  MarshallingInfoFlag<"FrontendOpts.DisableFree">;
 def fno_modules_global_index : Flag<["-"], "fno-modules-global-index">,
   HelpText<"Do not automatically generate or update the global module index">,
-  MarshallingInfoFlag<"FrontendOpts.UseGlobalModuleIndex", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"FrontendOpts.UseGlobalModuleIndex">;
 def fmodules_embed_all_files : Joined<["-"], "fmodules-embed-all-files">,
   HelpText<"Embed the contents of all files read by this compilation into "
            "the produced module file.">,
-  MarshallingInfoFlag<"FrontendOpts.ModulesEmbedAllFiles", "false">;
+  MarshallingInfoFlag<"FrontendOpts.ModulesEmbedAllFiles">;
 def ast_dump_decl_types : Flag<["-"], "ast-dump-decl-types">,
   Group<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">,
@@ -638,22 +639,22 @@
   AutoNormalizeEnum;
 def print_stats : Flag<["-"], "print-stats">,
   HelpText<"Print performance metrics and statistics">,
-  MarshallingInfoFlag<"FrontendOpts.ShowStats", "false">;
+  MarshallingInfoFlag<"FrontendOpts.ShowStats">;
 def fix_what_you_can : Flag<["-"], "fix-what-you-can">,
   HelpText<"Apply fix-it advice even in the presence of unfixable errors">,
-  MarshallingInfoFlag<"FrontendOpts.FixWhatYouCan", "false">;
+  MarshallingInfoFlag<"FrontendOpts.FixWhatYouCan">;
 def fix_only_warnings : Flag<["-"], "fix-only-warnings">,
   HelpText<"Apply fix-it advice only for warnings, not errors">,
-  MarshallingInfoFlag<"FrontendOpts.FixOnlyWarnings", "false">;
+  MarshallingInfoFlag<"FrontendOpts.FixOnlyWarnings">;
 def fixit_recompile : Flag<["-"], "fixit-recompile">,
   HelpText<"Apply fix-it changes and recompile">,
-  MarshallingInfoFlag<"FrontendOpts.FixAndRecompile", "false">;
+  MarshallingInfoFlag<"FrontendOpts.FixAndRecompile">;
 def fixit_to_temp : Flag<["-"], "fixit-to-temporary">,
   HelpText<"Apply fix-it changes to temporary files">,
-  MarshallingInfoFlag<"FrontendOpts.FixToTemporaries", "false">;
+  MarshallingInfoFlag<"FrontendOpts.FixToTemporaries">;
 def fno_pch_timestamp : Flag<["-"], "fno-pch-timestamp">,
   HelpText<"Disable inclusion of timestamp in precompiled headers">,
-  MarshallingInfoFlag<"FrontendOpts.IncludeTimestamps", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"FrontendOpts.IncludeTimestamps">;
 
 def ast_dump_filter : Separate<["-"], "ast-dump-filter">,
   MetaVarName<"<dump_filter>">,
@@ -680,7 +681,7 @@
 
 def version : Flag<["-"], "version">,
   HelpText<"Print the compiler version">,
-  MarshallingInfoFlag<"FrontendOpts.ShowVersion", "false">;
+  MarshallingInfoFlag<"FrontendOpts.ShowVersion">;
 
 } // Flags = [CC1Option, CC1AsOption, NoDriverOption]
 
@@ -734,21 +735,21 @@
   MarshallingInfoBooleanFlag<"CodeGenOpts.EmitVersionIdentMetadata", "true", Qn>;
 def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<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">,
@@ -756,7 +757,7 @@
                profile is accurate, callsites without profile samples are marked
                as cold. Otherwise, treat callsites without profile samples as if
                we have no profile}]>,
-   MarshallingInfoFlag<"CodeGenOpts.ProfileSampleAccurate", "false">;
+   MarshallingInfoFlag<"CodeGenOpts.ProfileSampleAccurate">;
 defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling",
   "Emit extra debug info to make sample profile more accurate", "", "", [], "CodeGenOpts.DebugInfoForProfiling">;
 defm coverage_mapping : OptInFFlag<"coverage-mapping",
@@ -765,7 +766,7 @@
 defm addrsig : OptInFFlag<"addrsig", "Emit", "Don't emit", " an address-significance table", [CoreOption], "CodeGenOpts.Addrsig">;
 def fcommon : Flag<["-"], "fcommon">, Group<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">;
@@ -791,27 +792,27 @@
   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">,
@@ -832,7 +833,7 @@
   HelpText<"Assume that overflowing float-to-int casts are undefined (default)">;
 def fno_strict_float_cast_overflow : Flag<["-"], "fno-strict-float-cast-overflow">, Group<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">;
@@ -841,13 +842,13 @@
   "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", "",
@@ -858,28 +859,28 @@
   "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">;
@@ -889,16 +890,16 @@
 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">;
@@ -906,7 +907,7 @@
 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",
@@ -927,82 +928,82 @@
 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=">,
@@ -1080,24 +1081,24 @@
 
 def debug_info_macro : Flag<["-"], "debug-info-macro">,
   HelpText<"Emit macro debug information">,
-  MarshallingInfoFlag<"CodeGenOpts.MacroDebugInfo", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.MacroDebugInfo">;
 def mno_exec_stack : Flag<["-"], "mnoexecstack">,
   HelpText<"Mark the file as not needing an executable stack">,
-  MarshallingInfoFlag<"CodeGenOpts.NoExecStack", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.NoExecStack">;
 def massembler_no_warn : Flag<["-"], "massembler-no-warn">,
   HelpText<"Make assembler not emit warnings">,
-  MarshallingInfoFlag<"CodeGenOpts.NoWarn", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.NoWarn">;
 def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
   HelpText<"Make assembler warnings fatal">,
-  MarshallingInfoFlag<"CodeGenOpts.FatalWarnings", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.FatalWarnings">;
 def mrelax_relocations : Flag<["--"], "mrelax-relocations">,
     HelpText<"Use relaxable elf relocations">,
-    MarshallingInfoFlag<"CodeGenOpts.RelaxELFRelocations", "false">;
+    MarshallingInfoFlag<"CodeGenOpts.RelaxELFRelocations">;
 def msave_temp_labels : Flag<["-"], "msave-temp-labels">,
   HelpText<"Save temporary labels in the symbol table. "
            "Note this may change .s semantics and shouldn't generally be used "
            "on compiler-generated code.">,
-  MarshallingInfoFlag<"CodeGenOpts.SaveTempLabels", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.SaveTempLabels">;
 
 def mrelocation_model : Separate<["-"], "mrelocation-model">,
   HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
@@ -1137,139 +1138,139 @@
 
 def disable_llvm_verifier : Flag<["-"], "disable-llvm-verifier">,
   HelpText<"Don't run the LLVM IR verifier pass">,
-  MarshallingInfoFlag<"CodeGenOpts.VerifyModule", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"CodeGenOpts.VerifyModule">;
 def disable_llvm_passes : Flag<["-"], "disable-llvm-passes">,
   HelpText<"Use together with -emit-llvm to get pristine LLVM IR from the "
            "frontend by not running any LLVM passes at all">,
-  MarshallingInfoFlag<"CodeGenOpts.DisableLLVMPasses", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.DisableLLVMPasses">;
 def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">,
   Alias<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",
@@ -1277,13 +1278,13 @@
   "Disables debug information for the new pass manager">;
 def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">,
     HelpText<"Emit Windows Control Flow Guard tables only (no checks)">,
-    MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuardNoChecks", "false">;
+    MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuardNoChecks">;
 def cfguard : Flag<["-"], "cfguard">,
     HelpText<"Emit Windows Control Flow Guard tables and checks">,
-    MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuard", "false">;
+    MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuard">;
 def discard_value_names : Flag<["-"], "discard-value-names">,
   HelpText<"Discard value names in LLVM IR">,
-  MarshallingInfoFlag<"CodeGenOpts.DiscardValueNames", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.DiscardValueNames">;
 def no_emit_llvm_uselists : Flag<["-"], "no-emit-llvm-uselists">,
   HelpText<"Don't preserve order of LLVM use-lists when serializing">;
 def emit_llvm_uselists : Flag<["-"], "emit-llvm-uselists">,
@@ -1291,7 +1292,7 @@
   MarshallingInfoBooleanFlag<"CodeGenOpts.EmitLLVMUseLists", "false", no_emit_llvm_uselists>;
 def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">,
   HelpText<"Preserve 3-component vector type">,
-  MarshallingInfoFlag<"CodeGenOpts.PreserveVec3Type", "false">;
+  MarshallingInfoFlag<"CodeGenOpts.PreserveVec3Type">;
 
 def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">,
   HelpText<"Incorporate CUDA device-side binary into host object file.">,
@@ -1361,15 +1362,15 @@
   Group<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:
@@ -1378,20 +1379,20 @@
   HelpText<"Compute and store the hash of input files used to build an AST."
            " Files with mismatching mtime's are considered valid"
            " if both contents is identical">,
-  MarshallingInfoFlag<"HeaderSearchOpts->ValidateASTInputFilesContent", "false">;
+  MarshallingInfoFlag<"HeaderSearchOpts->ValidateASTInputFilesContent">;
 def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<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>">,
@@ -1422,20 +1423,20 @@
 def fmodule_map_file_home_is_cwd : Flag<["-"], "fmodule-map-file-home-is-cwd">,
   HelpText<"Use the current working directory as the home directory of "
            "module maps specified by -fmodule-map-file=<FILE>">,
-  MarshallingInfoFlag<"HeaderSearchOpts->ModuleMapFileHomeIsCwd", "false">;
+  MarshallingInfoFlag<"HeaderSearchOpts->ModuleMapFileHomeIsCwd">;
 def nostdsysteminc : Flag<["-"], "nostdsysteminc">,
   HelpText<"Disable standard system #include directories">,
-  MarshallingInfoFlag<"HeaderSearchOpts->UseStandardSystemIncludes", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"HeaderSearchOpts->UseStandardSystemIncludes">;
 def fdisable_module_hash : Flag<["-"], "fdisable-module-hash">,
   HelpText<"Disable the module hash">,
-  MarshallingInfoFlag<"HeaderSearchOpts->DisableModuleHash", "false">;
+  MarshallingInfoFlag<"HeaderSearchOpts->DisableModuleHash">;
 def fmodules_hash_content : Flag<["-"], "fmodules-hash-content">,
   HelpText<"Enable hashing the content of a module file">,
-  MarshallingInfoFlag<"HeaderSearchOpts->ModulesHashContent", "false">;
+  MarshallingInfoFlag<"HeaderSearchOpts->ModulesHashContent">;
 def fmodules_strict_context_hash : Flag<["-"], "fmodules-strict-context-hash">,
   HelpText<"Enable hashing of all compiler options that could impact the "
            "semantics of a module in an implicit build">,
-  MarshallingInfoFlag<"HeaderSearchOpts->ModulesStrictContextHash", "false">;
+  MarshallingInfoFlag<"HeaderSearchOpts->ModulesStrictContextHash">;
 
 def fmodule_format_EQ : Joined<["-"], "fmodule-format=">,
   HelpText<"Select the container format for clang modules and PCH. "
@@ -1448,81 +1449,81 @@
 
 def cl_single_precision_constant : Flag<["-"], "cl-single-precision-constant">, Group<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">;
@@ -1534,7 +1535,7 @@
   "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">;
@@ -1542,25 +1543,25 @@
   "", "", [], "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",
@@ -1575,10 +1576,10 @@
 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">;
@@ -1592,56 +1593,56 @@
 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">;
 
@@ -1710,7 +1711,7 @@
 
 def fno_math_builtin : Flag<["-"], "fno-math-builtin">,
   HelpText<"Disable implicit builtin knowledge of math functions">,
-  MarshallingInfoFlag<"LangOpts->NoMathBuiltin", "false">; 
+  MarshallingInfoFlag<"LangOpts->NoMathBuiltin">; 
 
 } // Flags = [CC1Option, CC1AsOption, NoDriverOption]
 
@@ -1718,117 +1719,117 @@
 
 def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">,
   HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">,
-  MarshallingInfoFlag<"LangOpts->DumpVTableLayouts", "false">;
+  MarshallingInfoFlag<"LangOpts->DumpVTableLayouts">;
 def menable_no_infinities : Flag<["-"], "menable-no-infs">,
   HelpText<"Allow optimization to assume there are no infinities.">,
-  MarshallingInfoFlag<"LangOpts->NoHonorInfs", "false">;
+  MarshallingInfoFlag<"LangOpts->NoHonorInfs">;
 def menable_no_nans : Flag<["-"], "menable-no-nans">,
   HelpText<"Allow optimization to assume there are no NaNs.">,
-  MarshallingInfoFlag<"LangOpts->NoHonorNaNs", "false">;
+  MarshallingInfoFlag<"LangOpts->NoHonorNaNs">;
 def menable_unsafe_fp_math : Flag<["-"], "menable-unsafe-fp-math">,
   HelpText<"Allow unsafe floating-point math optimizations which may decrease "
            "precision">,
-  MarshallingInfoFlag<"LangOpts->UnsafeFPMath", "false">;
+  MarshallingInfoFlag<"LangOpts->UnsafeFPMath">;
 def mreassociate : Flag<["-"], "mreassociate">,
   HelpText<"Allow reassociation transformations for floating-point instructions">,
-  MarshallingInfoFlag<"LangOpts->AllowFPReassoc", "false">;
+  MarshallingInfoFlag<"LangOpts->AllowFPReassoc">;
 def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">,
   HelpText<"Use IEEE 754 quadruple-precision for long double">,
-  MarshallingInfoFlag<"LangOpts->PPCIEEELongDouble", "false">;
+  MarshallingInfoFlag<"LangOpts->PPCIEEELongDouble">;
 def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">,
-  MarshallingInfoFlag<"LangOpts->BranchTargetEnforcement", "false">;
+  MarshallingInfoFlag<"LangOpts->BranchTargetEnforcement">;
 def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">,
-  MarshallingInfoFlag<"LangOpts->DllExportInlines", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->DllExportInlines">;
 def fno_modules_error_recovery : Flag<["-"], "fno-modules-error-recovery">,
   HelpText<"Do not automatically import modules for error recovery">,
-  MarshallingInfoFlag<"LangOpts->ModulesErrorRecovery", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->ModulesErrorRecovery">;
 def fmodules_codegen :
   Flag<["-"], "fmodules-codegen">,
   HelpText<"Generate code for uses of this module that assumes an explicit "
            "object file will be built for the module">,
-  MarshallingInfoFlag<"LangOpts->ModulesCodegen", "false">;
+  MarshallingInfoFlag<"LangOpts->ModulesCodegen">;
 def fmodules_debuginfo :
   Flag<["-"], "fmodules-debuginfo">,
   HelpText<"Generate debug info for types in an object file built from this "
            "module and do not generate them elsewhere">,
-  MarshallingInfoFlag<"LangOpts->ModulesDebugInfo", "false">;
+  MarshallingInfoFlag<"LangOpts->ModulesDebugInfo">;
 def fno_concept_satisfaction_caching : Flag<["-"],
                                             "fno-concept-satisfaction-caching">,
   HelpText<"Disable satisfaction caching for C++2a Concepts.">,
-  MarshallingInfoFlag<"LangOpts->ConceptSatisfactionCaching", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->ConceptSatisfactionCaching">;
 defm recovery_ast_type : BooleanMarshalledFFlag<"recovery-ast-type", "LangOpts->RecoveryASTType", "false",
   "Preserve the type for recovery expressions when possible (experimental)">;
 def fdump_record_layouts_simple : Flag<["-"], "fdump-record-layouts-simple">,
   HelpText<"Dump record layout information in a simple form used for testing">,
-  MarshallingInfoFlag<"LangOpts->DumpRecordLayoutsSimple", "false">;
+  MarshallingInfoFlag<"LangOpts->DumpRecordLayoutsSimple">;
 def building_pch_with_obj : Flag<["-"], "building-pch-with-obj">,
   HelpText<"This compilation is part of building a PCH with corresponding object file.">,
-  MarshallingInfoFlag<"LangOpts->BuildingPCHWithObjectFile", "false">;
+  MarshallingInfoFlag<"LangOpts->BuildingPCHWithObjectFile">;
 def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">,
   HelpText<"Weakly link in the blocks runtime">,
-  MarshallingInfoFlag<"LangOpts->BlocksRuntimeOptional", "false">;
+  MarshallingInfoFlag<"LangOpts->BlocksRuntimeOptional">;
 def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">,
   HelpText<"Assume all functions with C linkage do not unwind">,
-  MarshallingInfoFlag<"LangOpts->ExternCNoUnwind", "false">;
+  MarshallingInfoFlag<"LangOpts->ExternCNoUnwind">;
 def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">,
   HelpText<"disable the default synthesis of Objective-C properties">,
-  MarshallingInfoFlag<"LangOpts->ObjCDefaultSynthProperties", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->ObjCDefaultSynthProperties">;
 def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">,
   HelpText<"enable extended encoding of block type signature">,
-  MarshallingInfoFlag<"LangOpts->EncodeExtendedBlockSig", "false">;
+  MarshallingInfoFlag<"LangOpts->EncodeExtendedBlockSig">;
 def pic_is_pie : Flag<["-"], "pic-is-pie">,
   HelpText<"File is for a position independent executable">,
-  MarshallingInfoFlag<"LangOpts->PIE", "false">;
+  MarshallingInfoFlag<"LangOpts->PIE">;
 def static_define : Flag<["-"], "static-define">,
   HelpText<"Should __STATIC__ be defined">,
-  MarshallingInfoFlag<"LangOpts->Static", "false">;
+  MarshallingInfoFlag<"LangOpts->Static">;
 def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">,
   HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">,
-  MarshallingInfoFlag<"LangOpts->SetVisibilityForExternDecls", "false">;
+  MarshallingInfoFlag<"LangOpts->SetVisibilityForExternDecls">;
 defm const_strings : BooleanMarshalledFFlag<"const-strings", "LangOpts->ConstStrings", "false",
   "Use a const qualified type for string literals in C and ObjC",
   "Don't use a const qualified type for string literals in C and ObjC">;
 def fno_bitfield_type_align : Flag<["-"], "fno-bitfield-type-align">,
   HelpText<"Ignore bit-field types when aligning structures">,
-  MarshallingInfoFlag<"LangOpts->NoBitFieldTypeAlign", "false">;
+  MarshallingInfoFlag<"LangOpts->NoBitFieldTypeAlign">;
 def ffake_address_space_map : Flag<["-"], "ffake-address-space-map">,
   HelpText<"Use a fake address space map; OpenCL testing purposes only">,
-  MarshallingInfoFlag<"LangOpts->FakeAddressSpaceMap", "false">;
+  MarshallingInfoFlag<"LangOpts->FakeAddressSpaceMap">;
 def funknown_anytype : Flag<["-"], "funknown-anytype">,
   HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">,
-  MarshallingInfoFlag<"LangOpts->ParseUnknownAnytype", "false">;
+  MarshallingInfoFlag<"LangOpts->ParseUnknownAnytype">;
 def fdebugger_support : Flag<["-"], "fdebugger-support">,
   HelpText<"Enable special debugger support behavior">,
-  MarshallingInfoFlag<"LangOpts->DebuggerSupport", "false">;
+  MarshallingInfoFlag<"LangOpts->DebuggerSupport">;
 def fdebugger_cast_result_to_id : Flag<["-"], "fdebugger-cast-result-to-id">,
   HelpText<"Enable casting unknown expression results to id">,
-  MarshallingInfoFlag<"LangOpts->DebuggerCastResultToId", "false">;
+  MarshallingInfoFlag<"LangOpts->DebuggerCastResultToId">;
 def fdebugger_objc_literal : Flag<["-"], "fdebugger-objc-literal">,
   HelpText<"Enable special debugger support for Objective-C subscripting and literals">,
-  MarshallingInfoFlag<"LangOpts->DebuggerObjCLiteral", "false">;
+  MarshallingInfoFlag<"LangOpts->DebuggerObjCLiteral">;
 defm deprecated_macro : BooleanMarshalledFFlag<"deprecated-macro", "LangOpts->Deprecated", "false",
   "Defines the __DEPRECATED macro", "Undefines the __DEPRECATED macro">;
 def finclude_default_header : Flag<["-"], "finclude-default-header">,
   HelpText<"Include default header file for OpenCL">,
-  MarshallingInfoFlag<"LangOpts->IncludeDefaultHeader", "false">;
+  MarshallingInfoFlag<"LangOpts->IncludeDefaultHeader">;
 def fdeclare_opencl_builtins : Flag<["-"], "fdeclare-opencl-builtins">,
   HelpText<"Add OpenCL builtin function declarations (experimental)">,
-  MarshallingInfoFlag<"LangOpts->DeclareOpenCLBuiltins", "false">;
+  MarshallingInfoFlag<"LangOpts->DeclareOpenCLBuiltins">;
 defm signed_wchar : BooleanMarshalledFFlag<"signed-wchar", "LangOpts->WCharIsSigned", "true",
   "Use a signed type for wchar_t", "Use an unsigned type for wchar_t">;
 def fcompatibility_qualified_id_block_param_type_checking : Flag<["-"], "fcompatibility-qualified-id-block-type-checking">,
   HelpText<"Allow using blocks with parameters of more specific type than "
            "the type system guarantees when a parameter is qualified id">,
-  MarshallingInfoFlag<"LangOpts->CompatibilityQualifiedIdBlockParamTypeChecking", "false">;
+  MarshallingInfoFlag<"LangOpts->CompatibilityQualifiedIdBlockParamTypeChecking">;
 def fcuda_is_device : Flag<["-"], "fcuda-is-device">,
   HelpText<"Generate code for CUDA device">,
-  MarshallingInfoFlag<"LangOpts->CUDAIsDevice", "false">;
+  MarshallingInfoFlag<"LangOpts->CUDAIsDevice">;
 def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">,
   HelpText<"Allow variadic functions in CUDA device code.">,
-  MarshallingInfoFlag<"LangOpts->CUDAAllowVariadicFunctions", "false">;
+  MarshallingInfoFlag<"LangOpts->CUDAAllowVariadicFunctions">;
 def fno_cuda_host_device_constexpr : Flag<["-"], "fno-cuda-host-device-constexpr">,
   HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">,
-  MarshallingInfoFlag<"LangOpts->CUDAHostDeviceConstexpr", "true">, IsNegative;
+  MarshallingInfoNegativeFlag<"LangOpts->CUDAHostDeviceConstexpr">;
 
 def fconstant_string_class : Separate<["-"], "fconstant-string-class">,
   MetaVarName<"<class name>">,
@@ -1900,7 +1901,7 @@
 
 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>">,
@@ -1910,25 +1911,25 @@
 
 def pch_through_hdrstop_create : Flag<["-"], "pch-through-hdrstop-create">,
   HelpText<"When creating a PCH, stop PCH generation after #pragma hdrstop.">,
-  MarshallingInfoFlag<"PreprocessorOpts->PCHWithHdrStopCreate", "false">;
+  MarshallingInfoFlag<"PreprocessorOpts->PCHWithHdrStopCreate">;
 def fno_validate_pch : Flag<["-"], "fno-validate-pch">,
   HelpText<"Disable validation of precompiled headers">,
-  MarshallingInfoFlag<"PreprocessorOpts->DisablePCHValidation", "false">;
+  MarshallingInfoFlag<"PreprocessorOpts->DisablePCHValidation">;
 def fallow_pch_with_errors : Flag<["-"], "fallow-pch-with-compiler-errors">,
   HelpText<"Accept a PCH file that was created with compiler errors">,
-  MarshallingInfoFlag<"PreprocessorOpts->AllowPCHWithCompilerErrors", "false">;
+  MarshallingInfoFlag<"PreprocessorOpts->AllowPCHWithCompilerErrors">;
 def dump_deserialized_pch_decls : Flag<["-"], "dump-deserialized-decls">,
   HelpText<"Dump declarations that are deserialized from PCH, for testing">,
-  MarshallingInfoFlag<"PreprocessorOpts->DumpDeserializedPCHDecls", "false">;
+  MarshallingInfoFlag<"PreprocessorOpts->DumpDeserializedPCHDecls">;
 def detailed_preprocessing_record : Flag<["-"], "detailed-preprocessing-record">,
   HelpText<"include a detailed record of preprocessing actions">,
-  MarshallingInfoFlag<"PreprocessorOpts->DetailedRecord", "false">;
+  MarshallingInfoFlag<"PreprocessorOpts->DetailedRecord">;
 def setup_static_analyzer : Flag<["-"], "setup-static-analyzer">,
   HelpText<"Set up preprocessor for static analyzer (done automatically when static analyzer is run).">,
-  MarshallingInfoFlag<"PreprocessorOpts->SetUpStaticAnalyzer", "false">;
+  MarshallingInfoFlag<"PreprocessorOpts->SetUpStaticAnalyzer">;
 def disable_pragma_debug_crash : Flag<["-"], "disable-pragma-debug-crash">,
   HelpText<"Disable any #pragma clang __debug that can lead to crashing behavior. This is meant for testing.">,
-  MarshallingInfoFlag<"PreprocessorOpts->DisablePragmaDebugCrash", "false">;
+  MarshallingInfoFlag<"PreprocessorOpts->DisablePragmaDebugCrash">;
 
 def pch_through_header_EQ : Joined<["-"], "pch-through-header=">,
   HelpText<"Stop PCH generation after including this file.  When using a PCH, "
@@ -1945,16 +1946,16 @@
 
 def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group<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",
@@ -4409,7 +4410,7 @@
 
 def analysis_UnoptimizedCFG : Flag<["-"], "unoptimized-cfg">,
   HelpText<"Generate unoptimized CFGs for all analyses">,
-  MarshallingInfoFlag<"AnalyzerOpts->UnoptimizedCFG", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->UnoptimizedCFG">;
 def analysis_CFGAddImplicitDtors : Flag<["-"], "cfg-add-implicit-dtors">,
   HelpText<"Add C++ implicit destructors to CFGs for all analyses">;
 
@@ -4433,23 +4434,23 @@
 
 def analyzer_opt_analyze_headers : Flag<["-"], "analyzer-opt-analyze-headers">,
   HelpText<"Force the static analyzer to analyze functions defined in header files">,
-  MarshallingInfoFlag<"AnalyzerOpts->AnalyzeAll", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->AnalyzeAll">;
 def analyzer_opt_analyze_nested_blocks : Flag<["-"], "analyzer-opt-analyze-nested-blocks">,
   HelpText<"Analyze the definitions of blocks in addition to functions">,
-  MarshallingInfoFlag<"AnalyzerOpts->AnalyzeNestedBlocks", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->AnalyzeNestedBlocks">;
 def analyzer_display_progress : Flag<["-"], "analyzer-display-progress">,
   HelpText<"Emit verbose output about the analyzer's progress">,
-  MarshallingInfoFlag<"AnalyzerOpts->AnalyzerDisplayProgress", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->AnalyzerDisplayProgress">;
 def analyze_function : Separate<["-"], "analyze-function">,
   HelpText<"Run analysis on specific function (for C++ include parameters in name)">,
   MarshallingInfoString<"AnalyzerOpts->AnalyzeSpecificFunction">;
 def analyze_function_EQ : Joined<["-"], "analyze-function=">, Alias<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">;
@@ -4467,14 +4468,14 @@
 
 def analyzer_disable_retry_exhausted : Flag<["-"], "analyzer-disable-retry-exhausted">,
   HelpText<"Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)">,
-  MarshallingInfoFlag<"AnalyzerOpts->NoRetryExhausted", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->NoRetryExhausted">;
 
 def analyzer_max_loop : Separate<["-"], "analyzer-max-loop">,
   HelpText<"The maximum number of times the analyzer will go through a loop">,
   MarshallingInfoStringInt<"AnalyzerOpts->maxBlockVisitOnPath", "4">;
 def analyzer_stats : Flag<["-"], "analyzer-stats">,
   HelpText<"Print internal analyzer statistics.">,
-  MarshallingInfoFlag<"AnalyzerOpts->PrintStats", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->PrintStats">;
 
 def analyzer_checker : Separate<["-"], "analyzer-checker">,
   HelpText<"Choose analyzer checkers to enable">,
@@ -4500,49 +4501,49 @@
 
 def analyzer_disable_all_checks : Flag<["-"], "analyzer-disable-all-checks">,
   HelpText<"Disable all static analyzer checks">,
-  MarshallingInfoFlag<"AnalyzerOpts->DisableAllCheckers", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->DisableAllCheckers">;
 
 def analyzer_checker_help : Flag<["-"], "analyzer-checker-help">,
   HelpText<"Display the list of analyzer checkers that are available">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelp", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelp">;
 
 def analyzer_checker_help_alpha : Flag<["-"], "analyzer-checker-help-alpha">,
   HelpText<"Display the list of in development analyzer checkers. These "
            "are NOT considered safe, they are unstable and will emit incorrect "
            "reports. Enable ONLY FOR DEVELOPMENT purposes">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpAlpha", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpAlpha">;
 
 def analyzer_checker_help_developer : Flag<["-"], "analyzer-checker-help-developer">,
   HelpText<"Display the list of developer-only checkers such as modeling "
            "and debug checkers">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpDeveloper", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerHelpDeveloper">;
 
 def analyzer_config_help : Flag<["-"], "analyzer-config-help">,
   HelpText<"Display the list of -analyzer-config options. These are meant for "
            "development purposes only!">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowConfigOptionsList", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowConfigOptionsList">;
 
 def analyzer_list_enabled_checkers : Flag<["-"], "analyzer-list-enabled-checkers">,
   HelpText<"Display the list of enabled analyzer checkers">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowEnabledCheckerList", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowEnabledCheckerList">;
 
 def analyzer_config : Separate<["-"], "analyzer-config">,
   HelpText<"Choose analyzer options to enable">;
 
 def analyzer_checker_option_help : Flag<["-"], "analyzer-checker-option-help">,
   HelpText<"Display the list of checker and package options">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionList", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionList">;
 
 def analyzer_checker_option_help_alpha : Flag<["-"], "analyzer-checker-option-help-alpha">,
   HelpText<"Display the list of in development checker and package options. "
            "These are NOT considered safe, they are unstable and will emit "
            "incorrect reports. Enable ONLY FOR DEVELOPMENT purposes">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionAlphaList", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionAlphaList">;
 
 def analyzer_checker_option_help_developer : Flag<["-"], "analyzer-checker-option-help-developer">,
   HelpText<"Display the list of checker and package options meant for "
            "development purposes only">,
-  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionDeveloperList", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->ShowCheckerOptionDeveloperList">;
 
 def analyzer_config_compatibility_mode : Separate<["-"], "analyzer-config-compatibility-mode">,
   HelpText<"Don't emit errors on invalid analyzer-config inputs">;
@@ -4552,18 +4553,18 @@
 
 def analyzer_werror : Flag<["-"], "analyzer-werror">,
   HelpText<"Emit analyzer results as errors rather than warnings">,
-  MarshallingInfoFlag<"AnalyzerOpts->AnalyzerWerror", "false">;
+  MarshallingInfoFlag<"AnalyzerOpts->AnalyzerWerror">;
 
 //===----------------------------------------------------------------------===//
 // Migrator Options
 //===----------------------------------------------------------------------===//
 def migrator_no_nsalloc_error : Flag<["-"], "no-ns-alloc-error">,
   HelpText<"Do not error on use of NSAllocateCollectable/NSReallocateCollectable">,
-  MarshallingInfoFlag<"MigratorOpts.NoNSAllocReallocError", "false">;
+  MarshallingInfoFlag<"MigratorOpts.NoNSAllocReallocError">;
 
 def migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">,
   HelpText<"Do not remove finalize method in gc mode">,
-  MarshallingInfoFlag<"MigratorOpts.NoFinalizeRemoval", "false">;
+  MarshallingInfoFlag<"MigratorOpts.NoFinalizeRemoval">;
 
 //===----------------------------------------------------------------------===//
 // CodeGen Options
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to