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
