This is an archive of the discontinued LLVM Phabricator instance.

Differential D84669

[clang][cli] Port CodeGenOpts simple string flags to new option parsing system
ClosedPublic

Authored by jansvoboda11 on Jul 27 2020, 9:53 AM.

Details

Reviewers
dang
Bigcheese
dexonsmith
Commits
rG95d3cc67caac: [clang][cli] Port CodeGenOpts simple string flags to new option parsing system
Summary

Depends on D84668

Diff Detail

Event Timeline

dang created this revision.Jul 27 2020, 9:53 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 27 2020, 9:53 AM
Herald added subscribers: cfe-commits, dexonsmith. · View Herald Transcript
dang added a child revision: D84670: [clang][cli] Port HeaderSearch simple string options to new option parsing system.Jul 27 2020, 9:54 AM
Harbormaster failed remote builds in B65855: Diff 280952!Jul 27 2020, 9:54 AM
jansvoboda11 commandeered this revision.Dec 15 2020, 4:56 AM
jansvoboda11 added a reviewer: dang.
jansvoboda11 added a subscriber: jansvoboda11.

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

jansvoboda11 retitled this revision from Port CodeGenOpts simple string flags to new option parsing system to [clang][cli] Port CodeGenOpts simple string flags to new option parsing system.Dec 15 2020, 4:56 AM
jansvoboda11 retitled this revision from [clang][cli] Port CodeGenOpts simple string flags to new option parsing system to WIP [clang][cli] Port CodeGenOpts simple string flags to new option parsing system.Dec 15 2020, 7:46 AM
jansvoboda11 updated this revision to Diff 311919.Dec 15 2020, 8:28 AM

Rebase, move options back to their original lines

jansvoboda11 retitled this revision from WIP [clang][cli] Port CodeGenOpts simple string flags to new option parsing system to [clang][cli] Port CodeGenOpts simple string flags to new option parsing system.Dec 15 2020, 8:29 AM
Harbormaster completed remote builds in B82468: Diff 311919.Dec 15 2020, 8:29 AM
jansvoboda11 added reviewers: Bigcheese, dexonsmith.Dec 15 2020, 8:29 AM
Bigcheese accepted this revision.Dec 17 2020, 8:56 AM

lgtm with the comment.

clang/include/clang/Driver/Options.td
2123–2125

This should have a comment saying that the cc1 semantics are different from the driver semantics.

This revision is now accepted and ready to land.Dec 17 2020, 8:56 AM
This revision was landed with ongoing or failed builds.Dec 18 2020, 1:29 AM
Closed by commit rG95d3cc67caac: [clang][cli] Port CodeGenOpts simple string flags to new option parsing system (authored by jansvoboda11). · Explain Why
This revision was automatically updated to reflect the committed changes.
jansvoboda11 added a commit: rG95d3cc67caac: [clang][cli] Port CodeGenOpts simple string flags to new option parsing system.
thakis added a reverting change: rG7ad666798f12: Revert 741978d727 and things that landed on top of it..Dec 23 2020, 9:59 AM
jansvoboda11 mentioned this in D94488: [clang][cli] Port more CodeGenOptions to marshalling infrastructure.Jan 12 2021, 3:39 AM
jansvoboda11 mentioned this in rG3bccd87a588b: [clang][cli] NFC: Remove SSPBufferSize assignment.Jan 14 2021, 4:22 AM

Revision Contents

PathSize
clang/
include/
clang/
Basic/
2 lines
2 lines
Driver/
140 lines
lib/
Frontend/
223 lines
test/
Profile/
2 lines

Diff 311919

clang/include/clang/Basic/CodeGenOptions.h

//===--- CodeGenOptions.h ---------------------------------------*- C++ -*-===// //===--- CodeGenOptions.h ---------------------------------------*- C++ -*-===//
Lint: Lint
Inline Actions

clang-format not found in user's PATH; not linting file.

Lint: Lint: clang-format not found in user's PATH; not linting file.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
Show All 16 Lines
#include <string> #include <string>
#include <vector> #include <vector>
namespace clang { namespace clang {
/// Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure /// Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure
/// that this large collection of bitfields is a trivial class type. /// that this large collection of bitfields is a trivial class type.
class CodeGenOptionsBase { class CodeGenOptionsBase {
friend class CompilerInvocation;
public: public:
#define CODEGENOPT(Name, Bits, Default) unsigned Name : Bits; #define CODEGENOPT(Name, Bits, Default) unsigned Name : Bits;
#define ENUM_CODEGENOPT(Name, Type, Bits, Default) #define ENUM_CODEGENOPT(Name, Type, Bits, Default)
#include "clang/Basic/CodeGenOptions.def" #include "clang/Basic/CodeGenOptions.def"
protected: protected:
#define CODEGENOPT(Name, Bits, Default) #define CODEGENOPT(Name, Bits, Default)
#define ENUM_CODEGENOPT(Name, Type, Bits, Default) unsigned Name : Bits; #define ENUM_CODEGENOPT(Name, Type, Bits, Default) unsigned Name : Bits;
▲ Show 20 Lines • Show All 384 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticDriverKinds.td

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Linesdef err_drv_bad_target_id : Error<"Invalid target ID: %0 (A target ID is a processor name "
"followed by an optional list of predefined features post-fixed by a plus or minus sign deliminated " "followed by an optional list of predefined features post-fixed by a plus or minus sign deliminated "
"by colon, e.g. 'gfx908:sramecc+:xnack-')">; "by colon, e.g. 'gfx908:sramecc+:xnack-')">;
def err_drv_bad_offload_arch_combo : Error<"Invalid offload arch combinations: %0 and %1 (For a specific " def err_drv_bad_offload_arch_combo : Error<"Invalid offload arch combinations: %0 and %1 (For a specific "
"processor, a feature should either exist in all offload archs, or not exist in any offload archs)">; "processor, a feature should either exist in all offload archs, or not exist in any offload archs)">;
def err_drv_invalid_thread_model_for_target : Error< def err_drv_invalid_thread_model_for_target : Error<
"invalid thread model '%0' in '%1' for this target">; "invalid thread model '%0' in '%1' for this target">;
def err_drv_invalid_linker_name : Error< def err_drv_invalid_linker_name : Error<
"invalid linker name in argument '%0'">; "invalid linker name in argument '%0'">;
def err_drv_invalid_pgo_instrumentor : Error<
"invalid PGO instrumentor in argument '%0'">;
def err_drv_invalid_rtlib_name : Error< def err_drv_invalid_rtlib_name : Error<
"invalid runtime library name in argument '%0'">; "invalid runtime library name in argument '%0'">;
def err_drv_unsupported_rtlib_for_platform : Error< def err_drv_unsupported_rtlib_for_platform : Error<
"unsupported runtime library '%0' for platform '%1'">; "unsupported runtime library '%0' for platform '%1'">;
def err_drv_invalid_unwindlib_name : Error< def err_drv_invalid_unwindlib_name : Error<
"invalid unwind library name in argument '%0'">; "invalid unwind library name in argument '%0'">;
def err_drv_incompatible_unwindlib : Error< def err_drv_incompatible_unwindlib : Error<
"--rtlib=libgcc requires --unwindlib=libgcc">; "--rtlib=libgcc requires --unwindlib=libgcc">;
▲ Show 20 Lines • Show All 443 Lines • Show Last 20 Lines

clang/include/clang/Driver/Options.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,040 Lines • ▼ Show 20 Linesdefm autolink : BoolFOption<"autolink",
ChangedBy<NegFlag, [CC1Option], "Disable generation of linker directives for automatic library linking">, ChangedBy<NegFlag, [CC1Option], "Disable generation of linker directives for automatic library linking">,
ResetBy<PosFlag>>; ResetBy<PosFlag>>;
// C++ Coroutines TS // C++ Coroutines TS
defm coroutines_ts : OptInFFlag<"coroutines-ts", "Enable support for the C++ Coroutines TS">; defm coroutines_ts : OptInFFlag<"coroutines-ts", "Enable support for the C++ Coroutines TS">;
def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">, def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">,
Group<f_Group>, Flags<[NoXarchOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">, Group<f_Group>, Flags<[NoXarchOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">,
HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">; HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">,
Values<"off,all,bitcode,marker">, NormalizedValuesScope<"CodeGenOptions">,
NormalizedValues<["Embed_Off", "Embed_All", "Embed_Bitcode", "Embed_Marker"]>,
MarshallingInfoString<"CodeGenOpts.EmbedBitcode", "Embed_Off">, AutoNormalizeEnum;
def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>, def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>,
Alias<fembed_bitcode_EQ>, AliasArgs<["all"]>, Alias<fembed_bitcode_EQ>, AliasArgs<["all"]>,
HelpText<"Embed LLVM IR bitcode as data">; HelpText<"Embed LLVM IR bitcode as data">;
def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">, def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">,
Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>, Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>,
HelpText<"Embed placeholder LLVM IR data as a marker">; HelpText<"Embed placeholder LLVM IR data as a marker">;
defm gnu_inline_asm : OptOutFFlag<"gnu-inline-asm", "", "Disable GNU style inline asm">; defm gnu_inline_asm : OptOutFFlag<"gnu-inline-asm", "", "Disable GNU style inline asm">;
def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>, def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>,
Flags<[CoreOption]>; Flags<[CoreOption]>;
def fno_profile_sample_use : Flag<["-"], "fno-profile-sample-use">, Group<f_Group>, def fno_profile_sample_use : Flag<["-"], "fno-profile-sample-use">, Group<f_Group>,
Flags<[CoreOption]>; Flags<[CoreOption]>;
def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">, def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">,
Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, Group<f_Group>, Flags<[NoXarchOption, CC1Option]>,
HelpText<"Enable sample-based profile guided optimizations">; HelpText<"Enable sample-based profile guided optimizations">,
MarshallingInfoString<"CodeGenOpts.SampleProfileFile">;
def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">, def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">,
Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, Group<f_Group>, Flags<[NoXarchOption, CC1Option]>,
HelpText<"Specifies that the sample profile is accurate">, HelpText<"Specifies that the sample profile is accurate">,
DocBrief<[{Specifies that the sample profile is accurate. If the sample DocBrief<[{Specifies that the sample profile is accurate. If the sample
profile is accurate, callsites without profile samples are marked profile is accurate, callsites without profile samples are marked
as cold. Otherwise, treat callsites without profile samples as if as cold. Otherwise, treat callsites without profile samples as if
we have no profile}]>; we have no profile}]>;
def fno_profile_sample_accurate : Flag<["-"], "fno-profile-sample-accurate">, def fno_profile_sample_accurate : Flag<["-"], "fno-profile-sample-accurate">,
Group<f_Group>, Flags<[NoXarchOption]>; Group<f_Group>, Flags<[NoXarchOption]>;
def fauto_profile : Flag<["-"], "fauto-profile">, Group<f_Group>, def fauto_profile : Flag<["-"], "fauto-profile">, Group<f_Group>,
Alias<fprofile_sample_use>; Alias<fprofile_sample_use>;
def fno_auto_profile : Flag<["-"], "fno-auto-profile">, Group<f_Group>, def fno_auto_profile : Flag<["-"], "fno-auto-profile">, Group<f_Group>,
Alias<fno_profile_sample_use>; Alias<fno_profile_sample_use>;
def fauto_profile_EQ : Joined<["-"], "fauto-profile=">, def fauto_profile_EQ : Joined<["-"], "fauto-profile=">,
Alias<fprofile_sample_use_EQ>; Alias<fprofile_sample_use_EQ>;
def fauto_profile_accurate : Flag<["-"], "fauto-profile-accurate">, def fauto_profile_accurate : Flag<["-"], "fauto-profile-accurate">,
Group<f_Group>, Alias<fprofile_sample_accurate>; Group<f_Group>, Alias<fprofile_sample_accurate>;
def fno_auto_profile_accurate : Flag<["-"], "fno-auto-profile-accurate">, def fno_auto_profile_accurate : Flag<["-"], "fno-auto-profile-accurate">,
Group<f_Group>, Alias<fno_profile_sample_accurate>; Group<f_Group>, Alias<fno_profile_sample_accurate>;
def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">, def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">,
Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>, Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>,
HelpText<"The compilation directory to embed in the debug info.">; HelpText<"The compilation directory to embed in the debug info.">,
MarshallingInfoString<"CodeGenOpts.DebugCompilationDir">;
def fdebug_compilation_dir_EQ : Joined<["-"], "fdebug-compilation-dir=">, def fdebug_compilation_dir_EQ : Joined<["-"], "fdebug-compilation-dir=">,
Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>, Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>,
Alias<fdebug_compilation_dir>; Alias<fdebug_compilation_dir>;
defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling", defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling",
"Emit extra debug info to make sample profile more accurate">; "Emit extra debug info to make sample profile more accurate">;
def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">, def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">,
Group<f_Group>, Flags<[CoreOption]>, Group<f_Group>, Flags<[CoreOption]>,
HelpText<"Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">; HelpText<"Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">;
def fprofile_instr_generate_EQ : Joined<["-"], "fprofile-instr-generate=">, def fprofile_instr_generate_EQ : Joined<["-"], "fprofile-instr-generate=">,
Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<file>">, Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<file>">,
HelpText<"Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)">; HelpText<"Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)">;
def fprofile_instr_use : Flag<["-"], "fprofile-instr-use">, Group<f_Group>, def fprofile_instr_use : Flag<["-"], "fprofile-instr-use">, Group<f_Group>,
Flags<[CoreOption]>; Flags<[CoreOption]>;
def fprofile_instr_use_EQ : Joined<["-"], "fprofile-instr-use=">, def fprofile_instr_use_EQ : Joined<["-"], "fprofile-instr-use=">,
Group<f_Group>, Flags<[CoreOption]>, Group<f_Group>, Flags<[CoreOption]>,
HelpText<"Use instrumentation data for profile-guided optimization">; HelpText<"Use instrumentation data for profile-guided optimization">;
def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">, def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">,
Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">,
HelpText<"Use the remappings described in <file> to match the profile data against names in the program">; HelpText<"Use the remappings described in <file> to match the profile data against names in the program">,
MarshallingInfoString<"CodeGenOpts.ProfileRemappingFile">;
def fprofile_remapping_file : Separate<["-"], "fprofile-remapping-file">, def fprofile_remapping_file : Separate<["-"], "fprofile-remapping-file">,
Group<f_Group>, Flags<[CoreOption]>, Alias<fprofile_remapping_file_EQ>; Group<f_Group>, Flags<[CoreOption]>, Alias<fprofile_remapping_file_EQ>;
defm coverage_mapping : OptInFFlag<"coverage-mapping", defm coverage_mapping : OptInFFlag<"coverage-mapping",
"Generate coverage mapping to enable code coverage analysis", "Disable code coverage analysis", "", "Generate coverage mapping to enable code coverage analysis", "Disable code coverage analysis", "",
[CoreOption]>; [CoreOption]>;
def fprofile_generate : Flag<["-"], "fprofile-generate">, def fprofile_generate : Flag<["-"], "fprofile-generate">,
Group<f_Group>, Flags<[CoreOption]>, Group<f_Group>, Flags<[CoreOption]>,
HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">; HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Lines
def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>; def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>;
defm jump_tables : OptOutFFlag<"jump-tables", "Use", "Do not use", " jump tables for lowering switches">; defm jump_tables : OptOutFFlag<"jump-tables", "Use", "Do not use", " jump tables for lowering switches">;
defm force_enable_int128 : OptInFFlag<"force-enable-int128", "Enable", "Disable", " support for int128_t type", [], "TargetOpts->ForceEnableInt128">; defm force_enable_int128 : OptInFFlag<"force-enable-int128", "Enable", "Disable", " support for int128_t type", [], "TargetOpts->ForceEnableInt128">;
defm keep_static_consts : OptInFFlag<"keep-static-consts", "Keep", "Don't keep", " static const variables if unused", [NoXarchOption]>; defm keep_static_consts : OptInFFlag<"keep-static-consts", "Keep", "Don't keep", " static const variables if unused", [NoXarchOption]>;
defm fixed_point : OptInFFlag<"fixed-point", "Enable", "Disable", " fixed point types">; defm fixed_point : OptInFFlag<"fixed-point", "Enable", "Disable", " fixed point types">;
defm cxx_static_destructors : OptOutFFlag<"c++-static-destructors", "", defm cxx_static_destructors : OptOutFFlag<"c++-static-destructors", "",
"Disable C++ static destructor registration">; "Disable C++ static destructor registration">;
def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>, def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>,
Flags<[CC1Option]>; Flags<[CC1Option]>, MarshallingInfoString<"CodeGenOpts.SymbolPartition">;
defm memory_profile : OptInFFlag<"memory-profile", "Enable", "Disable", " heap memory profiling">; defm memory_profile : OptInFFlag<"memory-profile", "Enable", "Disable", " heap memory profiling">;
def fmemory_profile_EQ : Joined<["-"], "fmemory-profile=">, def fmemory_profile_EQ : Joined<["-"], "fmemory-profile=">,
Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<directory>">, Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<directory>">,
HelpText<"Enable heap memory profiling and dump results into <directory>">; HelpText<"Enable heap memory profiling and dump results into <directory>">;
// Begin sanitizer flags. These should all be core options exposed in all driver // Begin sanitizer flags. These should all be core options exposed in all driver
// modes. // modes.
Show All 32 Lines
def fsanitize_coverage_blocklist : Joined<["-"], "fsanitize-coverage-blocklist=">, def fsanitize_coverage_blocklist : Joined<["-"], "fsanitize-coverage-blocklist=">,
Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>, Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>,
HelpText<"Disable sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones">; HelpText<"Disable sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones">;
def : Joined<["-"], "fsanitize-coverage-blacklist=">, def : Joined<["-"], "fsanitize-coverage-blacklist=">,
Group<f_clang_Group>, Flags<[CoreOption, HelpHidden]>, Alias<fsanitize_coverage_blocklist>, Group<f_clang_Group>, Flags<[CoreOption, HelpHidden]>, Alias<fsanitize_coverage_blocklist>,
HelpText<"Deprecated, use -fsanitize-coverage-blocklist= instead">; HelpText<"Deprecated, use -fsanitize-coverage-blocklist= instead">;
def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">, def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">,
Group<f_clang_Group>, Group<f_clang_Group>,
HelpText<"Enable origins tracking in MemorySanitizer">; HelpText<"Enable origins tracking in MemorySanitizer">,
MarshallingInfoStringInt<"CodeGenOpts.SanitizeMemoryTrackOrigins">;
def fsanitize_memory_track_origins : Flag<["-"], "fsanitize-memory-track-origins">, def fsanitize_memory_track_origins : Flag<["-"], "fsanitize-memory-track-origins">,
Group<f_clang_Group>, Group<f_clang_Group>,
HelpText<"Enable origins tracking in MemorySanitizer">; HelpText<"Enable origins tracking in MemorySanitizer">;
def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-origins">, def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-origins">,
Group<f_clang_Group>, Group<f_clang_Group>,
Flags<[CoreOption, NoXarchOption]>, Flags<[CoreOption, NoXarchOption]>,
HelpText<"Disable origins tracking in MemorySanitizer">; HelpText<"Disable origins tracking in MemorySanitizer">;
def fsanitize_memory_use_after_dtor : Flag<["-"], "fsanitize-memory-use-after-dtor">, def fsanitize_memory_use_after_dtor : Flag<["-"], "fsanitize-memory-use-after-dtor">,
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Linesdef fsanitize_thread_atomics : Flag<["-"], "fsanitize-thread-atomics">,
HelpText<"Enable atomic operations instrumentation in ThreadSanitizer (default)">; HelpText<"Enable atomic operations instrumentation in ThreadSanitizer (default)">;
def fno_sanitize_thread_atomics : Flag<["-"], "fno-sanitize-thread-atomics">, def fno_sanitize_thread_atomics : Flag<["-"], "fno-sanitize-thread-atomics">,
Group<f_clang_Group>, Group<f_clang_Group>,
Flags<[CoreOption, NoXarchOption]>, Flags<[CoreOption, NoXarchOption]>,
HelpText<"Disable atomic operations instrumentation in ThreadSanitizer">; HelpText<"Disable atomic operations instrumentation in ThreadSanitizer">;
def fsanitize_undefined_strip_path_components_EQ : Joined<["-"], "fsanitize-undefined-strip-path-components=">, def fsanitize_undefined_strip_path_components_EQ : Joined<["-"], "fsanitize-undefined-strip-path-components=">,
Group<f_clang_Group>, MetaVarName<"<number>">, Group<f_clang_Group>, MetaVarName<"<number>">,
HelpText<"Strip (or keep only, if negative) a given number of path components " HelpText<"Strip (or keep only, if negative) a given number of path components "
"when emitting check metadata.">; "when emitting check metadata.">,
MarshallingInfoStringInt<"CodeGenOpts.EmitCheckPathComponentsToStrip", "0", "int">;
} // end -f[no-]sanitize* flags } // end -f[no-]sanitize* flags
def funsafe_math_optimizations : Flag<["-"], "funsafe-math-optimizations">, def funsafe_math_optimizations : Flag<["-"], "funsafe-math-optimizations">,
Group<f_Group>; Group<f_Group>;
def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">, def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">,
Group<f_Group>; Group<f_Group>;
def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>; def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Linesdef fcf_protection : Flag<["-"], "fcf-protection">, Group<f_Group>, Flags<[CoreOption, CC1Option]>,
Alias<fcf_protection_EQ>, AliasArgs<["full"]>, Alias<fcf_protection_EQ>, AliasArgs<["full"]>,
HelpText<"Enable cf-protection in 'full' mode">; HelpText<"Enable cf-protection in 'full' mode">;
defm xray_instrument : OptInFFlag<"xray-instrument", "Generate XRay instrumentation sleds on function entry and exit", "", "", [], "LangOpts->XRayInstrument">; defm xray_instrument : OptInFFlag<"xray-instrument", "Generate XRay instrumentation sleds on function entry and exit", "", "", [], "LangOpts->XRayInstrument">;
def fxray_instruction_threshold_EQ : def fxray_instruction_threshold_EQ :
JoinedOrSeparate<["-"], "fxray-instruction-threshold=">, JoinedOrSeparate<["-"], "fxray-instruction-threshold=">,
Group<f_Group>, Flags<[CC1Option]>, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Sets the minimum function size to instrument with XRay">; HelpText<"Sets the minimum function size to instrument with XRay">,
MarshallingInfoStringInt<"CodeGenOpts.XRayInstructionThreshold", "200">;
def fxray_instruction_threshold_ : def fxray_instruction_threshold_ :
JoinedOrSeparate<["-"], "fxray-instruction-threshold">, JoinedOrSeparate<["-"], "fxray-instruction-threshold">,
Group<f_Group>, Flags<[CC1Option]>; Group<f_Group>, Flags<[CC1Option]>;
def fxray_always_instrument : def fxray_always_instrument :
JoinedOrSeparate<["-"], "fxray-always-instrument=">, JoinedOrSeparate<["-"], "fxray-always-instrument=">,
Group<f_Group>, Flags<[CC1Option]>, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.">; HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.">;
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Linesdef flto_jobs_EQ : Joined<["-"], "flto-jobs=">,
HelpText<"Controls the backend parallelism of -flto=thin (default " HelpText<"Controls the backend parallelism of -flto=thin (default "
"of 0 means the number of threads will be derived from " "of 0 means the number of threads will be derived from "
"the number of CPUs detected)">; "the number of CPUs detected)">;
def fthinlto_index_EQ : Joined<["-"], "fthinlto-index=">, def fthinlto_index_EQ : Joined<["-"], "fthinlto-index=">,
Flags<[CoreOption, CC1Option]>, Group<f_Group>, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
HelpText<"Perform ThinLTO importing using provided function summary index">; HelpText<"Perform ThinLTO importing using provided function summary index">;
def fthin_link_bitcode_EQ : Joined<["-"], "fthin-link-bitcode=">, def fthin_link_bitcode_EQ : Joined<["-"], "fthin-link-bitcode=">,
Flags<[CoreOption, CC1Option]>, Group<f_Group>, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">; HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">,
MarshallingInfoString<"CodeGenOpts.ThinLinkBitcodeFile">;
def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">, def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">,
Group<f_Group>, Flags<[NoXarchOption, CoreOption]>; Group<f_Group>, Flags<[NoXarchOption, CoreOption]>;
def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>, def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>,
Flags<[CC1Option, CoreOption]>, HelpText<"Allow merging of constants">; Flags<[CC1Option, CoreOption]>, HelpText<"Allow merging of constants">;
def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>, Flags<[CC1Option]>, def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Format message diagnostics so that they fit within N columns">; HelpText<"Format message diagnostics so that they fit within N columns">;
def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">; HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">;
▲ Show 20 Lines • Show All 171 Lines • ▼ Show 20 Lines
def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>; def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>; def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>; def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
def fno_global_isel : Flag<["-"], "fno-global-isel">, Group<f_clang_Group>, def fno_global_isel : Flag<["-"], "fno-global-isel">, Group<f_clang_Group>,
HelpText<"Disables the global instruction selector">; HelpText<"Disables the global instruction selector">;
def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>, def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>,
Alias<fno_global_isel>; Alias<fno_global_isel>;
def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>, def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Use the given vector functions library">, Values<"Accelerate,libmvec,MASSV,SVML,none">; HelpText<"Use the given vector functions library">,
Values<"Accelerate,libmvec,MASSV,SVML,none">,
NormalizedValuesScope<"CodeGenOptions">,
NormalizedValues<["Accelerate", "LIBMVEC", "MASSV", "SVML", "NoLibrary"]>,
MarshallingInfoString<"CodeGenOpts.VecLib", "NoLibrary">, AutoNormalizeEnum;
def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>, def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
Alias<flax_vector_conversions_EQ>, AliasArgs<["none"]>; Alias<flax_vector_conversions_EQ>, AliasArgs<["none"]>;
def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>, def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
HelpText<"Disallow merging of constants">; HelpText<"Disallow merging of constants">;
def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>, def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
Flags<[NoXarchOption]>; Flags<[NoXarchOption]>;
def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>, def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>,
Flags<[NoXarchOption]>; Flags<[NoXarchOption]>;
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines
def fno_pack_struct : Flag<["-"], "fno-pack-struct">, Group<f_Group>; def fno_pack_struct : Flag<["-"], "fno-pack-struct">, Group<f_Group>;
def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1Option]>, def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Specify the default maximum struct packing alignment">; HelpText<"Specify the default maximum struct packing alignment">;
def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>, def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">; HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">;
def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>; def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>;
def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>, def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Recognize and construct Pascal-style string literals">; HelpText<"Recognize and construct Pascal-style string literals">;
def fpatchable_function_entry_EQ : Joined<["-"], "fpatchable-function-entry=">, Group<f_Group>, Flags<[CC1Option]>, def fpatchable_function_entry_EQ : Joined<["-"], "fpatchable-function-entry=">, Group<f_Group>, Flags<[CC1Option]>,
MetaVarName<"<N,M>">, HelpText<"Generate M NOPs before function entry and N-M NOPs after function entry">; MetaVarName<"<N,M>">, HelpText<"Generate M NOPs before function entry and N-M NOPs after function entry">,
MarshallingInfoStringInt<"CodeGenOpts.PatchableFunctionEntryCount">;
BigcheeseUnsubmitted
Not Done
ReplyInline Actions

This should have a comment saying that the cc1 semantics are different from the driver semantics.

Bigcheese: This should have a comment saying that the cc1 semantics are different from the driver…
def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>, def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Override the default ABI to return all structs on the stack">; HelpText<"Override the default ABI to return all structs on the stack">;
def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>; def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>;
def fpic : Flag<["-"], "fpic">, Group<f_Group>; def fpic : Flag<["-"], "fpic">, Group<f_Group>;
def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>; def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>;
def fpie : Flag<["-"], "fpie">, Group<f_Group>; def fpie : Flag<["-"], "fpie">, Group<f_Group>;
def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>; def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
defm plt : OptOutFFlag<"plt", "", defm plt : OptOutFFlag<"plt", "",
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines<https://www.speedscope.app>`_ for flamegraph visualization.}]>,
MarshallingInfoFlag<"FrontendOpts.TimeTrace">; MarshallingInfoFlag<"FrontendOpts.TimeTrace">;
def ftime_trace_granularity_EQ : Joined<["-"], "ftime-trace-granularity=">, Group<f_Group>, def ftime_trace_granularity_EQ : Joined<["-"], "ftime-trace-granularity=">, Group<f_Group>,
HelpText<"Minimum time granularity (in microseconds) traced by time profiler">, HelpText<"Minimum time granularity (in microseconds) traced by time profiler">,
Flags<[CC1Option, CoreOption]>; Flags<[CC1Option, CoreOption]>;
def fproc_stat_report : Joined<["-"], "fproc-stat-report">, Group<f_Group>, def fproc_stat_report : Joined<["-"], "fproc-stat-report">, Group<f_Group>,
HelpText<"Print subprocess statistics">; HelpText<"Print subprocess statistics">;
def fproc_stat_report_EQ : Joined<["-"], "fproc-stat-report=">, Group<f_Group>, def fproc_stat_report_EQ : Joined<["-"], "fproc-stat-report=">, Group<f_Group>,
HelpText<"Save subprocess statistics to the given file">; HelpText<"Save subprocess statistics to the given file">;
def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>; def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>,
Values<"global-dynamic,local-dynamic,initial-exec,local-exec">,
NormalizedValuesScope<"CodeGenOptions">,
NormalizedValues<["GeneralDynamicTLSModel", "LocalDynamicTLSModel", "InitialExecTLSModel", "LocalExecTLSModel"]>,
MarshallingInfoString<"CodeGenOpts.DefaultTLSModel", "GeneralDynamicTLSModel">, AutoNormalizeEnum;
def ftrapv : Flag<["-"], "ftrapv">, Group<f_Group>, Flags<[CC1Option]>, def ftrapv : Flag<["-"], "ftrapv">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Trap on integer overflow">; HelpText<"Trap on integer overflow">;
def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>, def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>,
MetaVarName<"<function name>">, MetaVarName<"<function name>">,
HelpText<"Specify the function to be called on overflow">; HelpText<"Specify the function to be called on overflow">;
def ftrapv_handler : Separate<["-"], "ftrapv-handler">, Group<f_Group>, Flags<[CC1Option]>; def ftrapv_handler : Separate<["-"], "ftrapv-handler">, Group<f_Group>, Flags<[CC1Option]>;
def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags<[CC1Option]>, def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Issue call to specified function rather than a trap instruction">; HelpText<"Issue call to specified function rather than a trap instruction">,
MarshallingInfoString<"CodeGenOpts.TrapFuncName">;
def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>; def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>;
def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>, def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
HelpText<"Turn on loop unroller">, Flags<[CC1Option]>; HelpText<"Turn on loop unroller">, Flags<[CC1Option]>;
def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>, def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
HelpText<"Turn off loop unroller">, Flags<[CC1Option]>; HelpText<"Turn off loop unroller">, Flags<[CC1Option]>;
defm reroll_loops : OptInFFlag<"reroll-loops", "Turn on loop reroller">; defm reroll_loops : OptInFFlag<"reroll-loops", "Turn on loop reroller">;
def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>, def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
HelpText<"Process trigraph sequences">, Flags<[CC1Option]>; HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>, def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Store string literals as writable data">; HelpText<"Store string literals as writable data">;
defm zero_initialized_in_bss : OptOutFFlag<"zero-initialized-in-bss", "", "Don't place zero initialized data in BSS">; defm zero_initialized_in_bss : OptOutFFlag<"zero-initialized-in-bss", "", "Don't place zero initialized data in BSS">;
defm function_sections : OptInFFlag<"function-sections", "Place each function in its own section">; defm function_sections : OptInFFlag<"function-sections", "Place each function in its own section">;
def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>, def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>,
Flags<[CC1Option, CC1AsOption]>, Flags<[CC1Option, CC1AsOption]>,
HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">, HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">,
DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>, DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>,
Values<"all,labels,none,list=">; Values<"all,labels,none,list=">,
MarshallingInfoString<"CodeGenOpts.BBSections", [{std::string("none")}]>;
defm data_sections : OptInFFlag<"data-sections", "Place each data in its own section">; defm data_sections : OptInFFlag<"data-sections", "Place each data in its own section">;
defm stack_size_section : OptInFFlag<"stack-size-section", "Emit section containing metadata on function stack sizes">; defm stack_size_section : OptInFFlag<"stack-size-section", "Emit section containing metadata on function stack sizes">;
defm unique_basic_block_section_names : OptInFFlag<"unique-basic-block-section-names", defm unique_basic_block_section_names : OptInFFlag<"unique-basic-block-section-names",
"Use unique names for basic block sections (ELF Only)">; "Use unique names for basic block sections (ELF Only)">;
defm unique_internal_linkage_names : OptInFFlag<"unique-internal-linkage-names", defm unique_internal_linkage_names : OptInFFlag<"unique-internal-linkage-names",
"Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path">; "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path">;
defm unique_section_names : OptOutFFlag<"unique-section-names", defm unique_section_names : OptOutFFlag<"unique-section-names",
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
def mwatchos_simulator_version_min_EQ : Joined<["-"], "mwatchos-simulator-version-min=">; def mwatchos_simulator_version_min_EQ : Joined<["-"], "mwatchos-simulator-version-min=">;
def mwatchsimulator_version_min_EQ : Joined<["-"], "mwatchsimulator-version-min=">, Alias<mwatchos_simulator_version_min_EQ>; def mwatchsimulator_version_min_EQ : Joined<["-"], "mwatchsimulator-version-min=">, Alias<mwatchos_simulator_version_min_EQ>;
def march_EQ : Joined<["-"], "march=">, Group<m_Group>, Flags<[CoreOption]>; def march_EQ : Joined<["-"], "march=">, Group<m_Group>, Flags<[CoreOption]>;
def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[NoXarchOption]>; def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[NoXarchOption]>;
def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>, Flags<[CC1Option]>, def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>, Flags<[CC1Option]>,
MarshallingInfoString<"TargetOpts->CodeModel", [{std::string("default")}]>; MarshallingInfoString<"TargetOpts->CodeModel", [{std::string("default")}]>;
def mtls_size_EQ : Joined<["-"], "mtls-size=">, Group<m_Group>, Flags<[NoXarchOption, CC1Option]>, def mtls_size_EQ : Joined<["-"], "mtls-size=">, Group<m_Group>, Flags<[NoXarchOption, CC1Option]>,
HelpText<"Specify bit size of immediate TLS offsets (AArch64 ELF only): " HelpText<"Specify bit size of immediate TLS offsets (AArch64 ELF only): "
"12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)">; "12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)">,
MarshallingInfoStringInt<"CodeGenOpts.TLSSize">;
def mimplicit_it_EQ : Joined<["-"], "mimplicit-it=">, Group<m_Group>; def mimplicit_it_EQ : Joined<["-"], "mimplicit-it=">, Group<m_Group>;
def mdefault_build_attributes : Joined<["-"], "mdefault-build-attributes">, Group<m_Group>; def mdefault_build_attributes : Joined<["-"], "mdefault-build-attributes">, Group<m_Group>;
def mno_default_build_attributes : Joined<["-"], "mno-default-build-attributes">, Group<m_Group>; def mno_default_build_attributes : Joined<["-"], "mno-default-build-attributes">, Group<m_Group>;
def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>; def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>;
def mconsole : Joined<["-"], "mconsole">, Group<m_Group>, Flags<[NoXarchOption]>; def mconsole : Joined<["-"], "mconsole">, Group<m_Group>, Flags<[NoXarchOption]>;
def mwindows : Joined<["-"], "mwindows">, Group<m_Group>, Flags<[NoXarchOption]>; def mwindows : Joined<["-"], "mwindows">, Group<m_Group>, Flags<[NoXarchOption]>;
def mdll : Joined<["-"], "mdll">, Group<m_Group>, Flags<[NoXarchOption]>; def mdll : Joined<["-"], "mdll">, Group<m_Group>, Flags<[NoXarchOption]>;
def municode : Joined<["-"], "municode">, Group<m_Group>, Flags<[NoXarchOption]>; def municode : Joined<["-"], "municode">, Group<m_Group>, Flags<[NoXarchOption]>;
Show All 36 Linesdef moutline : Flag<["-"], "moutline">, Group<f_clang_Group>, Flags<[CC1Option]>,
HelpText<"Enable function outlining (AArch64 only)">; HelpText<"Enable function outlining (AArch64 only)">;
def mno_outline : Flag<["-"], "mno-outline">, Group<f_clang_Group>, Flags<[CC1Option]>, def mno_outline : Flag<["-"], "mno-outline">, Group<f_clang_Group>, Flags<[CC1Option]>,
HelpText<"Disable function outlining (AArch64 only)">; HelpText<"Disable function outlining (AArch64 only)">;
def mno_ms_bitfields : Flag<["-"], "mno-ms-bitfields">, Group<m_Group>, def mno_ms_bitfields : Flag<["-"], "mno-ms-bitfields">, Group<m_Group>,
HelpText<"Do not set the default structure layout to be compatible with the Microsoft compiler standard">; HelpText<"Do not set the default structure layout to be compatible with the Microsoft compiler standard">;
def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>, def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Force realign the stack at entry to every function">; HelpText<"Force realign the stack at entry to every function">;
def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>, def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Set the stack alignment">; HelpText<"Set the stack alignment">,
MarshallingInfoStringInt<"CodeGenOpts.StackAlignment">;
def mstack_probe_size : Joined<["-"], "mstack-probe-size=">, Group<m_Group>, Flags<[CC1Option]>, def mstack_probe_size : Joined<["-"], "mstack-probe-size=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Set the stack probe size">; HelpText<"Set the stack probe size">,
MarshallingInfoStringInt<"CodeGenOpts.StackProbeSize", "4096">;
def mstack_arg_probe : Flag<["-"], "mstack-arg-probe">, Group<m_Group>, def mstack_arg_probe : Flag<["-"], "mstack-arg-probe">, Group<m_Group>,
HelpText<"Enable stack probes">; HelpText<"Enable stack probes">;
def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group<m_Group>, Flags<[CC1Option]>, def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Disable stack probes which are enabled by default">; HelpText<"Disable stack probes which are enabled by default">;
def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>, def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"The thread model to use, e.g. posix, single (posix by default)">, Values<"posix,single">; HelpText<"The thread model to use, e.g. posix, single (posix by default)">, Values<"posix,single">;
def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>, def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Set EABI type, e.g. 4, 5 or gnu (default depends on triple)">, Values<"default,4,5,gnu">, HelpText<"Set EABI type, e.g. 4, 5 or gnu (default depends on triple)">, Values<"default,4,5,gnu">,
▲ Show 20 Lines • Show All 290 Lines • ▼ Show 20 Lines
def mno_outline_atomics : Flag<["-"], "mno-outline-atomics">, Group<f_clang_Group>, Flags<[CC1Option]>, def mno_outline_atomics : Flag<["-"], "mno-outline-atomics">, Group<f_clang_Group>, Flags<[CC1Option]>,
HelpText<"Don't generate local calls to out-of-line atomic operations">; HelpText<"Don't generate local calls to out-of-line atomic operations">;
def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>, def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>,
HelpText<"Don't generate implicit floating point instructions">; HelpText<"Don't generate implicit floating point instructions">;
def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>; def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>;
def mrecip : Flag<["-"], "mrecip">, Group<m_Group>; def mrecip : Flag<["-"], "mrecip">, Group<m_Group>;
def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>; def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>;
def mprefer_vector_width_EQ : Joined<["-"], "mprefer-vector-width=">, Group<m_Group>, Flags<[CC1Option]>, def mprefer_vector_width_EQ : Joined<["-"], "mprefer-vector-width=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">; HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">,
MarshallingInfoString<"CodeGenOpts.PreferVectorWidth">;
def mstack_protector_guard_EQ : Joined<["-"], "mstack-protector-guard=">, Group<m_Group>, Flags<[CC1Option]>, def mstack_protector_guard_EQ : Joined<["-"], "mstack-protector-guard=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Use the given guard (global, tls) for addressing the stack-protector guard">; HelpText<"Use the given guard (global, tls) for addressing the stack-protector guard">;
def mstack_protector_guard_offset_EQ : Joined<["-"], "mstack-protector-guard-offset=">, Group<m_Group>, Flags<[CC1Option]>, def mstack_protector_guard_offset_EQ : Joined<["-"], "mstack-protector-guard-offset=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Use the given offset for addressing the stack-protector guard">; HelpText<"Use the given offset for addressing the stack-protector guard">;
def mstack_protector_guard_reg_EQ : Joined<["-"], "mstack-protector-guard-reg=">, Group<m_Group>, Flags<[CC1Option]>, def mstack_protector_guard_reg_EQ : Joined<["-"], "mstack-protector-guard-reg=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Use the given reg for addressing the stack-protector guard">; HelpText<"Use the given reg for addressing the stack-protector guard">;
def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_Group>, def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_Group>,
Flags<[CC1Option]>, Flags<[CC1Option]>,
▲ Show 20 Lines • Show All 1,152 Lines • ▼ Show 20 Linesdef migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">,
HelpText<"Do not remove finalize method in gc mode">, HelpText<"Do not remove finalize method in gc mode">,
MarshallingInfoFlag<"MigratorOpts.NoFinalizeRemoval">; MarshallingInfoFlag<"MigratorOpts.NoFinalizeRemoval">;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CodeGen Options // CodeGen Options
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
let Flags = [CC1Option, CC1AsOption, NoDriverOption] in { let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">; def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">,
Values<"line-tables-only,line-directives-only,constructor,limited,standalone,unused-types">,
NormalizedValuesScope<"codegenoptions">,
NormalizedValues<["DebugLineTablesOnly", "DebugDirectivesOnly", "DebugInfoConstructor",
"LimitedDebugInfo", "FullDebugInfo", "UnusedTypeInfo"]>,
MarshallingInfoString<"CodeGenOpts.DebugInfo", "NoDebugInfo">, AutoNormalizeEnum;
def debug_info_macro : Flag<["-"], "debug-info-macro">, def debug_info_macro : Flag<["-"], "debug-info-macro">,
HelpText<"Emit macro debug information">; HelpText<"Emit macro debug information">;
def default_function_attr : Separate<["-"], "default-function-attr">, def default_function_attr : Separate<["-"], "default-function-attr">,
HelpText<"Apply given attribute to all functions">; HelpText<"Apply given attribute to all functions">;
def dwarf_version_EQ : Joined<["-"], "dwarf-version=">; def dwarf_version_EQ : Joined<["-"], "dwarf-version=">,
def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">; MarshallingInfoStringInt<"CodeGenOpts.DwarfVersion">;
def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">,
Values<"gdb,lldb,sce">,
NormalizedValuesScope<"llvm::DebuggerKind">, NormalizedValues<["GDB", "LLDB", "SCE"]>,
MarshallingInfoString<"CodeGenOpts.DebuggerTuning", "Default">, AutoNormalizeEnum;
def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">, def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">,
HelpText<"The string to embed in the Dwarf debug flags record.">; HelpText<"The string to embed in the Dwarf debug flags record.">,
MarshallingInfoString<"CodeGenOpts.DwarfDebugFlags">;
def record_command_line : Separate<["-"], "record-command-line">, def record_command_line : Separate<["-"], "record-command-line">,
HelpText<"The string to embed in the .LLVM.command.line section.">; HelpText<"The string to embed in the .LLVM.command.line section.">,
MarshallingInfoString<"CodeGenOpts.RecordCommandLine">;
def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">, def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">,
HelpText<"DWARF debug sections compression type">; HelpText<"DWARF debug sections compression type">;
def compress_debug_sections : Flag<["-", "--"], "compress-debug-sections">, def compress_debug_sections : Flag<["-", "--"], "compress-debug-sections">,
Alias<compress_debug_sections_EQ>, AliasArgs<["zlib"]>; Alias<compress_debug_sections_EQ>, AliasArgs<["zlib"]>;
def mno_exec_stack : Flag<["-"], "mnoexecstack">, def mno_exec_stack : Flag<["-"], "mnoexecstack">,
HelpText<"Mark the file as not needing an executable stack">; HelpText<"Mark the file as not needing an executable stack">;
def massembler_no_warn : Flag<["-"], "massembler-no-warn">, def massembler_no_warn : Flag<["-"], "massembler-no-warn">,
HelpText<"Make assembler not emit warnings">; HelpText<"Make assembler not emit warnings">;
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linesdef fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfield-access">,
HelpText<"Use register sized accesses to bit-fields, when possible.">; HelpText<"Use register sized accesses to bit-fields, when possible.">;
def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">, def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">,
HelpText<"Turn off Type Based Alias Analysis">; HelpText<"Turn off Type Based Alias Analysis">;
def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">, def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">,
HelpText<"Turn off struct-path aware Type Based Alias Analysis">; HelpText<"Turn off struct-path aware Type Based Alias Analysis">;
def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">, def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">,
HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">; HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">;
def mdebug_pass : Separate<["-"], "mdebug-pass">, def mdebug_pass : Separate<["-"], "mdebug-pass">,
HelpText<"Enable additional debug output">; HelpText<"Enable additional debug output">,
MarshallingInfoString<"CodeGenOpts.DebugPass">;
def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">, def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">,
HelpText<"Specify which frame pointers to retain (all, non-leaf, none).">, Values<"all,non-leaf,none">; HelpText<"Specify which frame pointers to retain (all, non-leaf, none).">, Values<"all,non-leaf,none">,
NormalizedValuesScope<"CodeGenOptions::FramePointerKind">, NormalizedValues<["All", "NonLeaf", "None"]>,
MarshallingInfoString<"CodeGenOpts.FramePointer", "None">, AutoNormalizeEnum;
def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">, def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">,
HelpText<"Disable tail call optimization, keeping the call stack accurate">; HelpText<"Disable tail call optimization, keeping the call stack accurate">;
def menable_no_infinities : Flag<["-"], "menable-no-infs">, def menable_no_infinities : Flag<["-"], "menable-no-infs">,
HelpText<"Allow optimization to assume there are no infinities.">, HelpText<"Allow optimization to assume there are no infinities.">,
MarshallingInfoFlag<"LangOpts->NoHonorInfs">, ImpliedByAnyOf<[ffinite_math_only]>; MarshallingInfoFlag<"LangOpts->NoHonorInfs">, ImpliedByAnyOf<[ffinite_math_only]>;
def menable_no_nans : Flag<["-"], "menable-no-nans">, def menable_no_nans : Flag<["-"], "menable-no-nans">,
HelpText<"Allow optimization to assume there are no NaNs.">, HelpText<"Allow optimization to assume there are no NaNs.">,
MarshallingInfoFlag<"LangOpts->NoHonorNaNs">, ImpliedByAnyOf<[ffinite_math_only]>; MarshallingInfoFlag<"LangOpts->NoHonorNaNs">, ImpliedByAnyOf<[ffinite_math_only]>;
def mreassociate : Flag<["-"], "mreassociate">, def mreassociate : Flag<["-"], "mreassociate">,
HelpText<"Allow reassociation transformations for floating-point instructions">, HelpText<"Allow reassociation transformations for floating-point instructions">,
MarshallingInfoFlag<"LangOpts->AllowFPReassoc">, ImpliedByAnyOf<[menable_unsafe_fp_math]>; MarshallingInfoFlag<"LangOpts->AllowFPReassoc">, ImpliedByAnyOf<[menable_unsafe_fp_math]>;
def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">, def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">,
HelpText<"Use IEEE 754 quadruple-precision for long double">; HelpText<"Use IEEE 754 quadruple-precision for long double">;
def mfloat_abi : Separate<["-"], "mfloat-abi">, def mfloat_abi : Separate<["-"], "mfloat-abi">,
HelpText<"The float ABI to use">; HelpText<"The float ABI to use">,
MarshallingInfoString<"CodeGenOpts.FloatABI">;
def mtp : Separate<["-"], "mtp">, def mtp : Separate<["-"], "mtp">,
HelpText<"Mode for reading thread pointer">; HelpText<"Mode for reading thread pointer">;
def mlimit_float_precision : Separate<["-"], "mlimit-float-precision">, def mlimit_float_precision : Separate<["-"], "mlimit-float-precision">,
HelpText<"Limit float precision to the given value">; HelpText<"Limit float precision to the given value">,
MarshallingInfoString<"CodeGenOpts.LimitFloatPrecision">;
def split_stacks : Flag<["-"], "split-stacks">, def split_stacks : Flag<["-"], "split-stacks">,
HelpText<"Try to use a split stack if possible.">; HelpText<"Try to use a split stack if possible.">;
def mregparm : Separate<["-"], "mregparm">, def mregparm : Separate<["-"], "mregparm">,
HelpText<"Limit the number of registers available for integer arguments">; HelpText<"Limit the number of registers available for integer arguments">,
MarshallingInfoStringInt<"CodeGenOpts.NumRegisterParameters">;
def msmall_data_limit : Separate<["-"], "msmall-data-limit">, def msmall_data_limit : Separate<["-"], "msmall-data-limit">,
HelpText<"Put global and static data smaller than the limit into a special section">; HelpText<"Put global and static data smaller than the limit into a special section">,
MarshallingInfoStringInt<"CodeGenOpts.SmallDataLimit">;
def munwind_tables : Flag<["-"], "munwind-tables">, def munwind_tables : Flag<["-"], "munwind-tables">,
HelpText<"Generate unwinding tables for all functions">; HelpText<"Generate unwinding tables for all functions">;
def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">, def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">,
HelpText<"Emit complete constructors and destructors as aliases when possible">; HelpText<"Emit complete constructors and destructors as aliases when possible">;
def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">, def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">,
HelpText<"Link the given bitcode file before performing optimizations.">; HelpText<"Link the given bitcode file before performing optimizations.">;
def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">, def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">,
HelpText<"Link and internalize needed symbols from the given bitcode file " HelpText<"Link and internalize needed symbols from the given bitcode file "
"before performing optimizations.">; "before performing optimizations.">;
def mlink_cuda_bitcode : Separate<["-"], "mlink-cuda-bitcode">, def mlink_cuda_bitcode : Separate<["-"], "mlink-cuda-bitcode">,
Alias<mlink_builtin_bitcode>; Alias<mlink_builtin_bitcode>;
def vectorize_loops : Flag<["-"], "vectorize-loops">, def vectorize_loops : Flag<["-"], "vectorize-loops">,
HelpText<"Run the Loop vectorization passes">; HelpText<"Run the Loop vectorization passes">;
def vectorize_slp : Flag<["-"], "vectorize-slp">, def vectorize_slp : Flag<["-"], "vectorize-slp">,
HelpText<"Run the SLP vectorization passes">; HelpText<"Run the SLP vectorization passes">;
def dependent_lib : Joined<["--"], "dependent-lib=">, def dependent_lib : Joined<["--"], "dependent-lib=">,
HelpText<"Add dependent library">; HelpText<"Add dependent library">;
def linker_option : Joined<["--"], "linker-option=">, def linker_option : Joined<["--"], "linker-option=">,
HelpText<"Add linker option">; HelpText<"Add linker option">;
def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">, def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">,
HelpText<"Sanitizer coverage type">; HelpText<"Sanitizer coverage type">,
MarshallingInfoStringInt<"CodeGenOpts.SanitizeCoverageType">;
def fsanitize_coverage_indirect_calls def fsanitize_coverage_indirect_calls
: Flag<["-"], "fsanitize-coverage-indirect-calls">, : Flag<["-"], "fsanitize-coverage-indirect-calls">,
HelpText<"Enable sanitizer coverage for indirect calls">; HelpText<"Enable sanitizer coverage for indirect calls">;
def fsanitize_coverage_trace_bb def fsanitize_coverage_trace_bb
: Flag<["-"], "fsanitize-coverage-trace-bb">, : Flag<["-"], "fsanitize-coverage-trace-bb">,
HelpText<"Enable basic block tracing in sanitizer coverage">; HelpText<"Enable basic block tracing in sanitizer coverage">;
def fsanitize_coverage_trace_cmp def fsanitize_coverage_trace_cmp
: Flag<["-"], "fsanitize-coverage-trace-cmp">, : Flag<["-"], "fsanitize-coverage-trace-cmp">,
Show All 25 Lines
def fsanitize_coverage_no_prune def fsanitize_coverage_no_prune
: Flag<["-"], "fsanitize-coverage-no-prune">, : Flag<["-"], "fsanitize-coverage-no-prune">,
HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">; HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">;
def fsanitize_coverage_stack_depth def fsanitize_coverage_stack_depth
: Flag<["-"], "fsanitize-coverage-stack-depth">, : Flag<["-"], "fsanitize-coverage-stack-depth">,
HelpText<"Enable max stack depth tracing">; HelpText<"Enable max stack depth tracing">;
def fpatchable_function_entry_offset_EQ def fpatchable_function_entry_offset_EQ
: Joined<["-"], "fpatchable-function-entry-offset=">, MetaVarName<"<M>">, : Joined<["-"], "fpatchable-function-entry-offset=">, MetaVarName<"<M>">,
HelpText<"Generate M NOPs before function entry">; HelpText<"Generate M NOPs before function entry">,
MarshallingInfoStringInt<"CodeGenOpts.PatchableFunctionEntryOffset">;
def fprofile_instrument_EQ : Joined<["-"], "fprofile-instrument=">, def fprofile_instrument_EQ : Joined<["-"], "fprofile-instrument=">,
HelpText<"Enable PGO instrumentation. The accepted value is clang, llvm, " HelpText<"Enable PGO instrumentation. The accepted value is clang, llvm, "
"or none">, Values<"none,clang,llvm">; "or none">, Values<"none,clang,llvm,csllvm">,
NormalizedValuesScope<"CodeGenOptions">,
NormalizedValues<["ProfileNone", "ProfileClangInstr", "ProfileIRInstr", "ProfileCSIRInstr"]>,
MarshallingInfoString<"CodeGenOpts.ProfileInstr", "ProfileNone">, AutoNormalizeEnum;
def fprofile_instrument_path_EQ : Joined<["-"], "fprofile-instrument-path=">, def fprofile_instrument_path_EQ : Joined<["-"], "fprofile-instrument-path=">,
HelpText<"Generate instrumented code to collect execution counts into " HelpText<"Generate instrumented code to collect execution counts into "
"<file> (overridden by LLVM_PROFILE_FILE env var)">; "<file> (overridden by LLVM_PROFILE_FILE env var)">,
MarshallingInfoString<"CodeGenOpts.InstrProfileOutput">;
def fprofile_instrument_use_path_EQ : def fprofile_instrument_use_path_EQ :
Joined<["-"], "fprofile-instrument-use-path=">, Joined<["-"], "fprofile-instrument-use-path=">,
HelpText<"Specify the profile path in PGO use compilation">; HelpText<"Specify the profile path in PGO use compilation">,
MarshallingInfoString<"CodeGenOpts.ProfileInstrumentUsePath">;
def flto_visibility_public_std: def flto_visibility_public_std:
Flag<["-"], "flto-visibility-public-std">, Flag<["-"], "flto-visibility-public-std">,
HelpText<"Use public LTO visibility for classes in std and stdext namespaces">; HelpText<"Use public LTO visibility for classes in std and stdext namespaces">;
def flto_unit: Flag<["-"], "flto-unit">, def flto_unit: Flag<["-"], "flto-unit">,
HelpText<"Emit IR to support LTO unit features (CFI, whole program vtable opt)">; HelpText<"Emit IR to support LTO unit features (CFI, whole program vtable opt)">;
def fno_lto_unit: Flag<["-"], "fno-lto-unit">; def fno_lto_unit: Flag<["-"], "fno-lto-unit">;
def fdebug_pass_manager : Flag<["-"], "fdebug-pass-manager">, def fdebug_pass_manager : Flag<["-"], "fdebug-pass-manager">,
HelpText<"Prints debug information for the new pass manager">; HelpText<"Prints debug information for the new pass manager">;
▲ Show 20 Lines • Show All 277 Lines • ▼ Show 20 Lines
def arcmt_action_EQ : Joined<["-"], "arcmt-action=">, Flags<[CC1Option, NoDriverOption]>, def arcmt_action_EQ : Joined<["-"], "arcmt-action=">, Flags<[CC1Option, NoDriverOption]>,
HelpText<"The ARC migration action to take">, Values<"check,modify,migrate">, HelpText<"The ARC migration action to take">, Values<"check,modify,migrate">,
NormalizedValuesScope<"FrontendOptions">, NormalizedValuesScope<"FrontendOptions">,
NormalizedValues<["ARCMT_Check", "ARCMT_Modify", "ARCMT_Migrate"]>, NormalizedValues<["ARCMT_Check", "ARCMT_Modify", "ARCMT_Migrate"]>,
MarshallingInfoString<"FrontendOpts.ARCMTAction", "ARCMT_None">, MarshallingInfoString<"FrontendOpts.ARCMTAction", "ARCMT_None">,
AutoNormalizeEnumJoined; AutoNormalizeEnumJoined;
def opt_record_file : Separate<["-"], "opt-record-file">, def opt_record_file : Separate<["-"], "opt-record-file">,
HelpText<"File name to use for YAML optimization record output">; HelpText<"File name to use for YAML optimization record output">,
MarshallingInfoString<"CodeGenOpts.OptRecordFile">;
def opt_record_passes : Separate<["-"], "opt-record-passes">, def opt_record_passes : Separate<["-"], "opt-record-passes">,
HelpText<"Only record remark information for passes whose names match the given regular expression">; HelpText<"Only record remark information for passes whose names match the given regular expression">;
def opt_record_format : Separate<["-"], "opt-record-format">, def opt_record_format : Separate<["-"], "opt-record-format">,
HelpText<"The format used for serializing remarks (default: YAML)">; HelpText<"The format used for serializing remarks (default: YAML)">;
def print_stats : Flag<["-"], "print-stats">, def print_stats : Flag<["-"], "print-stats">,
HelpText<"Print performance metrics and statistics">, HelpText<"Print performance metrics and statistics">,
MarshallingInfoFlag<"FrontendOpts.ShowStats">; MarshallingInfoFlag<"FrontendOpts.ShowStats">;
Show All 40 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
let Flags = [CC1Option, CC1AsOption, NoDriverOption] in { let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
def version : Flag<["-"], "version">, def version : Flag<["-"], "version">,
HelpText<"Print the compiler version">, HelpText<"Print the compiler version">,
MarshallingInfoFlag<"FrontendOpts.ShowVersion">; MarshallingInfoFlag<"FrontendOpts.ShowVersion">;
def main_file_name : Separate<["-"], "main-file-name">, def main_file_name : Separate<["-"], "main-file-name">,
HelpText<"Main file name to use for debug info and source if missing">; HelpText<"Main file name to use for debug info and source if missing">,
MarshallingInfoString<"CodeGenOpts.MainFileName">;
def split_dwarf_output : Separate<["-"], "split-dwarf-output">, def split_dwarf_output : Separate<["-"], "split-dwarf-output">,
HelpText<"File name to use for split dwarf debug info output">; HelpText<"File name to use for split dwarf debug info output">,
MarshallingInfoString<"CodeGenOpts.SplitDwarfOutput">;
} }
def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">, def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">,
HelpText<"Weakly link in the blocks runtime">; HelpText<"Weakly link in the blocks runtime">;
def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">, def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">,
HelpText<"Assume all functions with C linkage do not unwind">; HelpText<"Assume all functions with C linkage do not unwind">;
def split_dwarf_file : Separate<["-"], "split-dwarf-file">, def split_dwarf_file : Separate<["-"], "split-dwarf-file">,
HelpText<"Name of the split dwarf debug info file to encode in the object file">; HelpText<"Name of the split dwarf debug info file to encode in the object file">,
MarshallingInfoString<"CodeGenOpts.SplitDwarfFile">;
def fno_wchar : Flag<["-"], "fno-wchar">, def fno_wchar : Flag<["-"], "fno-wchar">,
HelpText<"Disable C++ builtin type wchar_t">; HelpText<"Disable C++ builtin type wchar_t">;
def fconstant_string_class : Separate<["-"], "fconstant-string-class">, def fconstant_string_class : Separate<["-"], "fconstant-string-class">,
MetaVarName<"<class name>">, MetaVarName<"<class name>">,
HelpText<"Specify the class to use for constant Objective-C string objects.">; HelpText<"Specify the class to use for constant Objective-C string objects.">;
def fobjc_arc_cxxlib_EQ : Joined<["-"], "fobjc-arc-cxxlib=">, def fobjc_arc_cxxlib_EQ : Joined<["-"], "fobjc-arc-cxxlib=">,
HelpText<"Objective-C++ Automatic Reference Counting standard library kind">, Values<"libc++,libstdc++,none">; HelpText<"Objective-C++ Automatic Reference Counting standard library kind">, Values<"libc++,libstdc++,none">;
def fobjc_runtime_has_weak : Flag<["-"], "fobjc-runtime-has-weak">, def fobjc_runtime_has_weak : Flag<["-"], "fobjc-runtime-has-weak">,
HelpText<"The target Objective-C runtime supports ARC weak operations">; HelpText<"The target Objective-C runtime supports ARC weak operations">;
def fobjc_dispatch_method_EQ : Joined<["-"], "fobjc-dispatch-method=">, def fobjc_dispatch_method_EQ : Joined<["-"], "fobjc-dispatch-method=">,
HelpText<"Objective-C dispatch method to use">, Values<"legacy,non-legacy,mixed">; HelpText<"Objective-C dispatch method to use">, Values<"legacy,non-legacy,mixed">,
NormalizedValuesScope<"CodeGenOptions">, NormalizedValues<["Legacy", "NonLegacy", "Mixed"]>,
MarshallingInfoString<"CodeGenOpts.ObjCDispatchMethod", "Legacy">, AutoNormalizeEnum;
def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">, def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">,
HelpText<"disable the default synthesis of Objective-C properties">; HelpText<"disable the default synthesis of Objective-C properties">;
def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">, def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">,
HelpText<"enable extended encoding of block type signature">; HelpText<"enable extended encoding of block type signature">;
def function_alignment : Separate<["-"], "function-alignment">, def function_alignment : Separate<["-"], "function-alignment">,
HelpText<"default alignment for functions">; HelpText<"default alignment for functions">;
def pic_level : Separate<["-"], "pic-level">, def pic_level : Separate<["-"], "pic-level">,
HelpText<"Value for __PIC__">; HelpText<"Value for __PIC__">;
Show All 13 Linesdef error_on_deserialized_pch_decl : Separate<["-"], "error-on-deserialized-decl">,
HelpText<"Emit error if a specific declaration is deserialized from PCH, for testing">; HelpText<"Emit error if a specific declaration is deserialized from PCH, for testing">;
def error_on_deserialized_pch_decl_EQ : Joined<["-"], "error-on-deserialized-decl=">, def error_on_deserialized_pch_decl_EQ : Joined<["-"], "error-on-deserialized-decl=">,
Alias<error_on_deserialized_pch_decl>; Alias<error_on_deserialized_pch_decl>;
def static_define : Flag<["-"], "static-define">, def static_define : Flag<["-"], "static-define">,
HelpText<"Should __STATIC__ be defined">; HelpText<"Should __STATIC__ be defined">;
def stack_protector : Separate<["-"], "stack-protector">, def stack_protector : Separate<["-"], "stack-protector">,
HelpText<"Enable stack protectors">; HelpText<"Enable stack protectors">;
def stack_protector_buffer_size : Separate<["-"], "stack-protector-buffer-size">, def stack_protector_buffer_size : Separate<["-"], "stack-protector-buffer-size">,
HelpText<"Lower bound for a buffer to be considered for stack protection">; HelpText<"Lower bound for a buffer to be considered for stack protection">,
MarshallingInfoStringInt<"CodeGenOpts.SSPBufferSize", "8">;
def fvisibility : Separate<["-"], "fvisibility">, def fvisibility : Separate<["-"], "fvisibility">,
HelpText<"Default type and symbol visibility">; HelpText<"Default type and symbol visibility">;
def ftype_visibility : Separate<["-"], "ftype-visibility">, def ftype_visibility : Separate<["-"], "ftype-visibility">,
HelpText<"Default type visibility">; HelpText<"Default type visibility">;
def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">, def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">,
HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">; HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">;
def ftemplate_depth : Separate<["-"], "ftemplate-depth">, def ftemplate_depth : Separate<["-"], "ftemplate-depth">,
HelpText<"Maximum depth of recursive template instantiation">; HelpText<"Maximum depth of recursive template instantiation">;
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CUDA Options // CUDA Options
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def fcuda_is_device : Flag<["-"], "fcuda-is-device">, def fcuda_is_device : Flag<["-"], "fcuda-is-device">,
HelpText<"Generate code for CUDA device">; HelpText<"Generate code for CUDA device">;
def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">, def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">,
HelpText<"Incorporate CUDA device-side binary into host object file.">; HelpText<"Incorporate CUDA device-side binary into host object file.">,
MarshallingInfoString<"CodeGenOpts.CudaGpuBinaryFileName">;
def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">, def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">,
HelpText<"Allow variadic functions in CUDA device code.">; HelpText<"Allow variadic functions in CUDA device code.">;
def fno_cuda_host_device_constexpr : Flag<["-"], "fno-cuda-host-device-constexpr">, def fno_cuda_host_device_constexpr : Flag<["-"], "fno-cuda-host-device-constexpr">,
HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">; HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// OpenMP Options // OpenMP Options
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 514 Lines • Show Last 20 Lines

clang/lib/Frontend/CompilerInvocation.cpp

//===- CompilerInvocation.cpp ---------------------------------------------===// //===- CompilerInvocation.cpp ---------------------------------------------===//
Lint: Lint
Inline Actions

clang-format not found in user's PATH; not linting file.

Lint: Lint: clang-format not found in user's PATH; not linting file.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 333 Lines • ▼ Show 20 Lines
} }
template <typename T, typename U, U Value> template <typename T, typename U, U Value>
static T extractMaskValue(T KeyPath) { static T extractMaskValue(T KeyPath) {
return KeyPath & Value; return KeyPath & Value;
} }
static void FixupInvocation(CompilerInvocation &Invocation, static void FixupInvocation(CompilerInvocation &Invocation,
DiagnosticsEngine &Diags) { DiagnosticsEngine &Diags,
const InputArgList &Args) {
LangOptions &LangOpts = *Invocation.getLangOpts(); LangOptions &LangOpts = *Invocation.getLangOpts();
DiagnosticOptions &DiagOpts = Invocation.getDiagnosticOpts(); DiagnosticOptions &DiagOpts = Invocation.getDiagnosticOpts();
CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts(); CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts();
TargetOptions &TargetOpts = Invocation.getTargetOpts(); TargetOptions &TargetOpts = Invocation.getTargetOpts();
FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument; CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents; CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents; CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex; FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex;
llvm::sys::Process::UseANSIEscapeCodes(DiagOpts.UseANSIEscapeCodes); llvm::sys::Process::UseANSIEscapeCodes(DiagOpts.UseANSIEscapeCodes);
llvm::Triple T(TargetOpts.Triple); llvm::Triple T(TargetOpts.Triple);
if (LangOpts.getExceptionHandling() != llvm::ExceptionHandling::None && if (LangOpts.getExceptionHandling() != llvm::ExceptionHandling::None &&
T.isWindowsMSVCEnvironment()) T.isWindowsMSVCEnvironment())
Diags.Report(diag::err_fe_invalid_exception_model) Diags.Report(diag::err_fe_invalid_exception_model)
<< static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str(); << static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str();
if (!CodeGenOpts.ProfileRemappingFile.empty() && CodeGenOpts.LegacyPassManager)
Diags.Report(diag::err_drv_argument_only_allowed_with)
<< Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args)
<< "-fno-legacy-pass-manager";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Deserialization (from args) // Deserialization (from args)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static unsigned getOptimizationLevel(ArgList &Args, InputKind IK, static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
DiagnosticsEngine &Diags) { DiagnosticsEngine &Diags) {
▲ Show 20 Lines • Show All 426 Lines • ▼ Show 20 Lines if (Mask == XRayInstrKind::None)
S.Mask = Mask; S.Mask = Mask;
else if (Mask == XRayInstrKind::All) else if (Mask == XRayInstrKind::All)
S.Mask = Mask; S.Mask = Mask;
else else
S.set(Mask, true); S.set(Mask, true);
} }
} }
// Set the profile kind for fprofile-instrument.
static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args,
DiagnosticsEngine &Diags) {
Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ);
if (A == nullptr)
return;
StringRef S = A->getValue();
unsigned I = llvm::StringSwitch<unsigned>(S)
.Case("none", CodeGenOptions::ProfileNone)
.Case("clang", CodeGenOptions::ProfileClangInstr)
.Case("llvm", CodeGenOptions::ProfileIRInstr)
.Case("csllvm", CodeGenOptions::ProfileCSIRInstr)
.Default(~0U);
if (I == ~0U) {
Diags.Report(diag::err_drv_invalid_pgo_instrumentor) << A->getAsString(Args)
<< S;
return;
}
auto Instrumentor = static_cast<CodeGenOptions::ProfileInstrKind>(I);
Opts.setProfileInstr(Instrumentor);
}
// Set the profile kind using fprofile-instrument-use-path. // Set the profile kind using fprofile-instrument-use-path.
static void setPGOUseInstrumentor(CodeGenOptions &Opts, static void setPGOUseInstrumentor(CodeGenOptions &Opts,
const Twine &ProfileName) { const Twine &ProfileName) {
auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName); auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName);
// In error, return silently and let Clang PGOUse report the error message. // In error, return silently and let Clang PGOUse report the error message.
if (auto E = ReaderOrErr.takeError()) { if (auto E = ReaderOrErr.takeError()) {
llvm::consumeError(std::move(E)); llvm::consumeError(std::move(E));
Opts.setProfileUse(CodeGenOptions::ProfileClangInstr); Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines if (Opts.OptimizationLevel > 0) {
Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining); Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
} }
} }
Opts.DebugPassManager = Opts.DebugPassManager =
Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager, Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
/* Default */ false); /* Default */ false);
if (Arg *A = Args.getLastArg(OPT_fveclib)) {
StringRef Name = A->getValue();
if (Name == "Accelerate")
Opts.setVecLib(CodeGenOptions::Accelerate);
else if (Name == "libmvec")
Opts.setVecLib(CodeGenOptions::LIBMVEC);
else if (Name == "MASSV")
Opts.setVecLib(CodeGenOptions::MASSV);
else if (Name == "SVML")
Opts.setVecLib(CodeGenOptions::SVML);
else if (Name == "none")
Opts.setVecLib(CodeGenOptions::NoLibrary);
else
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
}
if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
unsigned Val =
llvm::StringSwitch<unsigned>(A->getValue())
.Case("line-tables-only", codegenoptions::DebugLineTablesOnly)
.Case("line-directives-only", codegenoptions::DebugDirectivesOnly)
.Case("constructor", codegenoptions::DebugInfoConstructor)
.Case("limited", codegenoptions::LimitedDebugInfo)
.Case("standalone", codegenoptions::FullDebugInfo)
.Case("unused-types", codegenoptions::UnusedTypeInfo)
.Default(~0U);
if (Val == ~0U)
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
<< A->getValue();
else
Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val));
}
// If -fuse-ctor-homing is set and limited debug info is already on, then use // If -fuse-ctor-homing is set and limited debug info is already on, then use
// constructor homing. // constructor homing.
if (Args.getLastArg(OPT_fuse_ctor_homing)) if (Args.getLastArg(OPT_fuse_ctor_homing))
if (Opts.getDebugInfo() == codegenoptions::LimitedDebugInfo) if (Opts.getDebugInfo() == codegenoptions::LimitedDebugInfo)
Opts.setDebugInfo(codegenoptions::DebugInfoConstructor); Opts.setDebugInfo(codegenoptions::DebugInfoConstructor);
if (Arg *A = Args.getLastArg(OPT_debugger_tuning_EQ)) {
unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
.Case("gdb", unsigned(llvm::DebuggerKind::GDB))
.Case("lldb", unsigned(llvm::DebuggerKind::LLDB))
.Case("sce", unsigned(llvm::DebuggerKind::SCE))
.Default(~0U);
if (Val == ~0U)
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
<< A->getValue();
else
Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val));
}
Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
Opts.DebugColumnInfo = !Args.hasArg(OPT_gno_column_info); Opts.DebugColumnInfo = !Args.hasArg(OPT_gno_column_info);
Opts.EmitCodeView = Args.hasArg(OPT_gcodeview); Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro); Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro);
Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables); Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
Opts.VirtualFunctionElimination = Opts.VirtualFunctionElimination =
Args.hasArg(OPT_fvirtual_function_elimination); Args.hasArg(OPT_fvirtual_function_elimination);
Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std); Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std);
Opts.SplitDwarfFile = std::string(Args.getLastArgValue(OPT_split_dwarf_file));
Opts.SplitDwarfOutput =
std::string(Args.getLastArgValue(OPT_split_dwarf_output));
Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining); Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining);
Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs); Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
Opts.DebugExplicitImport = Args.hasArg(OPT_dwarf_explicit_import); Opts.DebugExplicitImport = Args.hasArg(OPT_dwarf_explicit_import);
Opts.DebugFwdTemplateParams = Args.hasArg(OPT_debug_forward_template_params); Opts.DebugFwdTemplateParams = Args.hasArg(OPT_debug_forward_template_params);
Opts.EmbedSource = Args.hasArg(OPT_gembed_source); Opts.EmbedSource = Args.hasArg(OPT_gembed_source);
Opts.ForceDwarfFrameSection = Args.hasArg(OPT_fforce_dwarf_frame); Opts.ForceDwarfFrameSection = Args.hasArg(OPT_fforce_dwarf_frame);
for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) { for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
Show All 30 Lines Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
OPT_fuse_register_sized_bitfield_access); OPT_fuse_register_sized_bitfield_access);
Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing); Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa); Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) && Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
Args.hasArg(OPT_new_struct_path_tbaa); Args.hasArg(OPT_new_struct_path_tbaa);
Opts.FineGrainedBitfieldAccesses = Opts.FineGrainedBitfieldAccesses =
Args.hasFlag(OPT_ffine_grained_bitfield_accesses, Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
OPT_fno_fine_grained_bitfield_accesses, false); OPT_fno_fine_grained_bitfield_accesses, false);
Opts.DwarfDebugFlags =
std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
Opts.RecordCommandLine =
std::string(Args.getLastArgValue(OPT_record_command_line));
Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants); Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants);
Opts.NoCommon = !Args.hasArg(OPT_fcommon); Opts.NoCommon = !Args.hasArg(OPT_fcommon);
Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float); Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
Opts.OptimizeSize = getOptimizationLevelSize(Args); Opts.OptimizeSize = getOptimizationLevelSize(Args);
Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) || Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
Args.hasArg(OPT_ffreestanding)); Args.hasArg(OPT_ffreestanding));
if (Opts.SimplifyLibCalls) if (Opts.SimplifyLibCalls)
getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs); getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
Opts.UnrollLoops = Opts.UnrollLoops =
Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops, Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
(Opts.OptimizationLevel > 1)); (Opts.OptimizationLevel > 1));
Opts.RerollLoops = Args.hasArg(OPT_freroll_loops); Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as); Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
Opts.SampleProfileFile =
std::string(Args.getLastArgValue(OPT_fprofile_sample_use_EQ));
Opts.DebugInfoForProfiling = Args.hasFlag( Opts.DebugInfoForProfiling = Args.hasFlag(
OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false); OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
Opts.PseudoProbeForProfiling = Opts.PseudoProbeForProfiling =
Args.hasFlag(OPT_fpseudo_probe_for_profiling, Args.hasFlag(OPT_fpseudo_probe_for_profiling,
OPT_fno_pseudo_probe_for_profiling, false); OPT_fno_pseudo_probe_for_profiling, false);
Opts.DebugNameTable = static_cast<unsigned>( Opts.DebugNameTable = static_cast<unsigned>(
Args.hasArg(OPT_ggnu_pubnames) Args.hasArg(OPT_ggnu_pubnames)
? llvm::DICompileUnit::DebugNameTableKind::GNU ? llvm::DICompileUnit::DebugNameTableKind::GNU
: Args.hasArg(OPT_gpubnames) : Args.hasArg(OPT_gpubnames)
? llvm::DICompileUnit::DebugNameTableKind::Default ? llvm::DICompileUnit::DebugNameTableKind::Default
: llvm::DICompileUnit::DebugNameTableKind::None); : llvm::DICompileUnit::DebugNameTableKind::None);
Opts.DebugRangesBaseAddress = Args.hasArg(OPT_fdebug_ranges_base_address); Opts.DebugRangesBaseAddress = Args.hasArg(OPT_fdebug_ranges_base_address);
setPGOInstrumentor(Opts, Args, Diags);
Opts.AtomicProfileUpdate = Args.hasArg(OPT_fprofile_update_EQ); Opts.AtomicProfileUpdate = Args.hasArg(OPT_fprofile_update_EQ);
Opts.InstrProfileOutput =
std::string(Args.getLastArgValue(OPT_fprofile_instrument_path_EQ));
Opts.ProfileInstrumentUsePath =
std::string(Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ));
if (!Opts.ProfileInstrumentUsePath.empty()) if (!Opts.ProfileInstrumentUsePath.empty())
setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath); setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath);
Opts.ProfileRemappingFile =
std::string(Args.getLastArgValue(OPT_fprofile_remapping_file_EQ));
if (!Opts.ProfileRemappingFile.empty() && Opts.LegacyPassManager) {
Diags.Report(diag::err_drv_argument_only_allowed_with)
<< Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args)
<< "-fno-legacy-pass-manager";
}
Opts.CoverageMapping = Opts.CoverageMapping =
Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false); Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping); Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
Opts.AsmVerbose = !Args.hasArg(OPT_fno_verbose_asm); Opts.AsmVerbose = !Args.hasArg(OPT_fno_verbose_asm);
Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments); Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new); Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions); Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit); Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
Opts.RegisterGlobalDtorsWithAtExit = Opts.RegisterGlobalDtorsWithAtExit =
Args.hasArg(OPT_fregister_global_dtors_with_atexit); Args.hasArg(OPT_fregister_global_dtors_with_atexit);
Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases); Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
Opts.CodeModel = TargetOpts.CodeModel; Opts.CodeModel = TargetOpts.CodeModel;
Opts.DebugPass = std::string(Args.getLastArgValue(OPT_mdebug_pass));
// Handle -mframe-pointer option.
if (Arg *A = Args.getLastArg(OPT_mframe_pointer_EQ)) {
CodeGenOptions::FramePointerKind FP;
StringRef Name = A->getValue();
bool ValidFP = true;
if (Name == "none")
FP = CodeGenOptions::FramePointerKind::None;
else if (Name == "non-leaf")
FP = CodeGenOptions::FramePointerKind::NonLeaf;
else if (Name == "all")
FP = CodeGenOptions::FramePointerKind::All;
else {
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
Success = false;
ValidFP = false;
}
if (ValidFP)
Opts.setFramePointer(FP);
}
if (const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) { if (const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
Opts.TimePasses = true; Opts.TimePasses = true;
// -ftime-report= is only for new pass manager. // -ftime-report= is only for new pass manager.
if (A->getOption().getID() == OPT_ftime_report_EQ) { if (A->getOption().getID() == OPT_ftime_report_EQ) {
if (Opts.LegacyPassManager) if (Opts.LegacyPassManager)
Diags.Report(diag::err_drv_argument_only_allowed_with) Diags.Report(diag::err_drv_argument_only_allowed_with)
Show All 10 Lines if (const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
} }
} }
Opts.DisableFree = Args.hasArg(OPT_disable_free); Opts.DisableFree = Args.hasArg(OPT_disable_free);
Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names); Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls); Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
Opts.NoEscapingBlockTailCalls = Opts.NoEscapingBlockTailCalls =
Args.hasArg(OPT_fno_escaping_block_tail_calls); Args.hasArg(OPT_fno_escaping_block_tail_calls);
Opts.FloatABI = std::string(Args.getLastArgValue(OPT_mfloat_abi));
Opts.LimitFloatPrecision =
std::string(Args.getLastArgValue(OPT_mlimit_float_precision));
Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ); Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
Opts.StrictFloatCastOverflow = Opts.StrictFloatCastOverflow =
!Args.hasArg(OPT_fno_strict_float_cast_overflow); !Args.hasArg(OPT_fno_strict_float_cast_overflow);
Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_fno_zero_initialized_in_bss); Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_fno_zero_initialized_in_bss);
Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack); Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
Opts.SmallDataLimit =
getLastArgIntValue(Args, OPT_msmall_data_limit, 0, Diags);
Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings); Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn); Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks); Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
Opts.RelaxAll = Args.hasArg(OPT_mrelax_all); Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
Opts.IncrementalLinkerCompatible = Opts.IncrementalLinkerCompatible =
Args.hasArg(OPT_mincremental_linker_compatible); Args.hasArg(OPT_mincremental_linker_compatible);
Opts.PIECopyRelocations = Opts.PIECopyRelocations =
Args.hasArg(OPT_mpie_copy_relocations); Args.hasArg(OPT_mpie_copy_relocations);
Opts.NoPLT = Args.hasArg(OPT_fno_plt); Opts.NoPLT = Args.hasArg(OPT_fno_plt);
Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels); Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm); Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
Opts.SoftFloat = Args.hasArg(OPT_msoft_float); Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums); Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return); Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers); Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables); Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables);
Opts.UnwindTables = Args.hasArg(OPT_munwind_tables); Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
Opts.TrapFuncName = std::string(Args.getLastArgValue(OPT_ftrap_function_EQ));
Opts.UseInitArray = !Args.hasArg(OPT_fno_use_init_array); Opts.UseInitArray = !Args.hasArg(OPT_fno_use_init_array);
Opts.BBSections =
std::string(Args.getLastArgValue(OPT_fbasic_block_sections_EQ, "none"));
// Basic Block Sections implies Function Sections. // Basic Block Sections implies Function Sections.
Opts.FunctionSections = Opts.FunctionSections =
Args.hasArg(OPT_ffunction_sections) || Args.hasArg(OPT_ffunction_sections) ||
(Opts.BBSections != "none" && Opts.BBSections != "labels"); (Opts.BBSections != "none" && Opts.BBSections != "labels");
Opts.DataSections = Args.hasArg(OPT_fdata_sections); Opts.DataSections = Args.hasArg(OPT_fdata_sections);
Opts.StackSizeSection = Args.hasArg(OPT_fstack_size_section); Opts.StackSizeSection = Args.hasArg(OPT_fstack_size_section);
Opts.UniqueSectionNames = !Args.hasArg(OPT_fno_unique_section_names); Opts.UniqueSectionNames = !Args.hasArg(OPT_fno_unique_section_names);
Show All 31 Lines Opts.ThinLTOIndexFile =
std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ)); std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
} }
if (Arg *A = Args.getLastArg(OPT_save_temps_EQ)) if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
Opts.SaveTempsFilePrefix = Opts.SaveTempsFilePrefix =
llvm::StringSwitch<std::string>(A->getValue()) llvm::StringSwitch<std::string>(A->getValue())
.Case("obj", FrontendOpts.OutputFile) .Case("obj", FrontendOpts.OutputFile)
.Default(llvm::sys::path::filename(FrontendOpts.OutputFile).str()); .Default(llvm::sys::path::filename(FrontendOpts.OutputFile).str());
Opts.ThinLinkBitcodeFile =
std::string(Args.getLastArgValue(OPT_fthin_link_bitcode_EQ));
// The memory profile runtime appends the pid to make this name more unique. // The memory profile runtime appends the pid to make this name more unique.
const char *MemProfileBasename = "memprof.profraw"; const char *MemProfileBasename = "memprof.profraw";
if (Args.hasArg(OPT_fmemory_profile_EQ)) { if (Args.hasArg(OPT_fmemory_profile_EQ)) {
SmallString<128> Path( SmallString<128> Path(
std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ))); std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
llvm::sys::path::append(Path, MemProfileBasename); llvm::sys::path::append(Path, MemProfileBasename);
Opts.MemoryProfileOutput = std::string(Path); Opts.MemoryProfileOutput = std::string(Path);
} else if (Args.hasArg(OPT_fmemory_profile)) } else if (Args.hasArg(OPT_fmemory_profile))
Opts.MemoryProfileOutput = MemProfileBasename; Opts.MemoryProfileOutput = MemProfileBasename;
Opts.MSVolatile = Args.hasArg(OPT_fms_volatile); Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops); Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp); Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
Opts.PreferVectorWidth =
std::string(Args.getLastArgValue(OPT_mprefer_vector_width_EQ));
Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name));
Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier); Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
Opts.ControlFlowGuardNoChecks = Args.hasArg(OPT_cfguard_no_checks); Opts.ControlFlowGuardNoChecks = Args.hasArg(OPT_cfguard_no_checks);
Opts.ControlFlowGuard = Args.hasArg(OPT_cfguard); Opts.ControlFlowGuard = Args.hasArg(OPT_cfguard);
Opts.EmitGcovNotes = Args.hasArg(OPT_ftest_coverage); Opts.EmitGcovNotes = Args.hasArg(OPT_ftest_coverage);
Opts.EmitGcovArcs = Args.hasArg(OPT_fprofile_arcs); Opts.EmitGcovArcs = Args.hasArg(OPT_fprofile_arcs);
if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) { if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
Show All 11 Lines if (Args.hasArg(OPT_coverage_version_EQ)) {
Diags.Report(diag::err_drv_invalid_value) Diags.Report(diag::err_drv_invalid_value)
<< Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args) << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
<< CoverageVersion; << CoverageVersion;
} else { } else {
memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4); memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
} }
} }
} }
// Handle -fembed-bitcode option.
if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
StringRef Name = A->getValue();
unsigned Model = llvm::StringSwitch<unsigned>(Name)
.Case("off", CodeGenOptions::Embed_Off)
.Case("all", CodeGenOptions::Embed_All)
.Case("bitcode", CodeGenOptions::Embed_Bitcode)
.Case("marker", CodeGenOptions::Embed_Marker)
.Default(~0U);
if (Model == ~0U) {
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
Success = false;
} else
Opts.setEmbedBitcode(
static_cast<CodeGenOptions::EmbedBitcodeKind>(Model));
}
// FIXME: For backend options that are not yet recorded as function // FIXME: For backend options that are not yet recorded as function
// attributes in the IR, keep track of them so we can embed them in a // attributes in the IR, keep track of them so we can embed them in a
// separate data section and use them when building the bitcode. // separate data section and use them when building the bitcode.
for (const auto &A : Args) { for (const auto &A : Args) {
// Do not encode output and input. // Do not encode output and input.
if (A->getOption().getID() == options::OPT_o || if (A->getOption().getID() == options::OPT_o ||
A->getOption().getID() == options::OPT_INPUT || A->getOption().getID() == options::OPT_INPUT ||
A->getOption().getID() == options::OPT_x || A->getOption().getID() == options::OPT_x ||
Show All 12 Linesstatic bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type); Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions); Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
Opts.InstrumentFunctionsAfterInlining = Opts.InstrumentFunctionsAfterInlining =
Args.hasArg(OPT_finstrument_functions_after_inlining); Args.hasArg(OPT_finstrument_functions_after_inlining);
Opts.InstrumentFunctionEntryBare = Opts.InstrumentFunctionEntryBare =
Args.hasArg(OPT_finstrument_function_entry_bare); Args.hasArg(OPT_finstrument_function_entry_bare);
Opts.XRayInstructionThreshold =
getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
Opts.XRayTotalFunctionGroups = Opts.XRayTotalFunctionGroups =
getLastArgIntValue(Args, OPT_fxray_function_groups, 1, Diags); getLastArgIntValue(Args, OPT_fxray_function_groups, 1, Diags);
Opts.XRaySelectedFunctionGroup = Opts.XRaySelectedFunctionGroup =
getLastArgIntValue(Args, OPT_fxray_selected_function_group, 0, Diags); getLastArgIntValue(Args, OPT_fxray_selected_function_group, 0, Diags);
auto XRayInstrBundles = auto XRayInstrBundles =
Args.getAllArgValues(OPT_fxray_instrumentation_bundle); Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
if (XRayInstrBundles.empty()) if (XRayInstrBundles.empty())
Opts.XRayInstrumentationBundle.Mask = XRayInstrKind::All; Opts.XRayInstrumentationBundle.Mask = XRayInstrKind::All;
else else
for (const auto &A : XRayInstrBundles) for (const auto &A : XRayInstrBundles)
parseXRayInstrumentationBundle("-fxray-instrumentation-bundle=", A, Args, parseXRayInstrumentationBundle("-fxray-instrumentation-bundle=", A, Args,
Diags, Opts.XRayInstrumentationBundle); Diags, Opts.XRayInstrumentationBundle);
Opts.PatchableFunctionEntryCount =
getLastArgIntValue(Args, OPT_fpatchable_function_entry_EQ, 0, Diags);
Opts.PatchableFunctionEntryOffset = getLastArgIntValue(
Args, OPT_fpatchable_function_entry_offset_EQ, 0, Diags);
Opts.InstrumentForProfiling = Args.hasArg(OPT_pg); Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
Opts.CallFEntry = Args.hasArg(OPT_mfentry); Opts.CallFEntry = Args.hasArg(OPT_mfentry);
Opts.MNopMCount = Args.hasArg(OPT_mnop_mcount); Opts.MNopMCount = Args.hasArg(OPT_mnop_mcount);
Opts.RecordMCount = Args.hasArg(OPT_mrecord_mcount); Opts.RecordMCount = Args.hasArg(OPT_mrecord_mcount);
Opts.PackedStack = Args.hasArg(OPT_mpacked_stack); Opts.PackedStack = Args.hasArg(OPT_mpacked_stack);
if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) { if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
StringRef Name = A->getValue(); StringRef Name = A->getValue();
Show All 15 Lines auto DCT = llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
.Case("none", llvm::DebugCompressionType::None) .Case("none", llvm::DebugCompressionType::None)
.Case("zlib", llvm::DebugCompressionType::Z) .Case("zlib", llvm::DebugCompressionType::Z)
.Case("zlib-gnu", llvm::DebugCompressionType::GNU) .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
.Default(llvm::DebugCompressionType::None); .Default(llvm::DebugCompressionType::None);
Opts.setCompressDebugSections(DCT); Opts.setCompressDebugSections(DCT);
} }
Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations); Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
Opts.DebugCompilationDir =
std::string(Args.getLastArgValue(OPT_fdebug_compilation_dir));
for (auto *A : for (auto *A :
Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) { Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
CodeGenOptions::BitcodeFileToLink F; CodeGenOptions::BitcodeFileToLink F;
F.Filename = A->getValue(); F.Filename = A->getValue();
if (A->getOption().matches(OPT_mlink_builtin_bitcode)) { if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded; F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
// When linking CUDA bitcode, propagate function attributes so that // When linking CUDA bitcode, propagate function attributes so that
// e.g. libdevice gets fast-math attrs if we're building with fast-math. // e.g. libdevice gets fast-math attrs if we're building with fast-math.
F.PropagateAttrs = true; F.PropagateAttrs = true;
F.Internalize = true; F.Internalize = true;
} }
Opts.LinkBitcodeFiles.push_back(F); Opts.LinkBitcodeFiles.push_back(F);
} }
Opts.SanitizeCoverageType =
getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
Opts.SanitizeCoverageIndirectCalls = Opts.SanitizeCoverageIndirectCalls =
Args.hasArg(OPT_fsanitize_coverage_indirect_calls); Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb); Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp); Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div); Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep); Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
Opts.SanitizeCoverage8bitCounters = Opts.SanitizeCoverage8bitCounters =
Args.hasArg(OPT_fsanitize_coverage_8bit_counters); Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc); Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
Opts.SanitizeCoverageTracePCGuard = Opts.SanitizeCoverageTracePCGuard =
Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard); Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune); Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune);
Opts.SanitizeCoverageInline8bitCounters = Opts.SanitizeCoverageInline8bitCounters =
Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters); Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters);
Opts.SanitizeCoverageInlineBoolFlag = Opts.SanitizeCoverageInlineBoolFlag =
Args.hasArg(OPT_fsanitize_coverage_inline_bool_flag); Args.hasArg(OPT_fsanitize_coverage_inline_bool_flag);
Opts.SanitizeCoveragePCTable = Args.hasArg(OPT_fsanitize_coverage_pc_table); Opts.SanitizeCoveragePCTable = Args.hasArg(OPT_fsanitize_coverage_pc_table);
Opts.SanitizeCoverageStackDepth = Opts.SanitizeCoverageStackDepth =
Args.hasArg(OPT_fsanitize_coverage_stack_depth); Args.hasArg(OPT_fsanitize_coverage_stack_depth);
Opts.SanitizeCoverageAllowlistFiles = Opts.SanitizeCoverageAllowlistFiles =
Args.getAllArgValues(OPT_fsanitize_coverage_allowlist); Args.getAllArgValues(OPT_fsanitize_coverage_allowlist);
Opts.SanitizeCoverageBlocklistFiles = Opts.SanitizeCoverageBlocklistFiles =
Args.getAllArgValues(OPT_fsanitize_coverage_blocklist); Args.getAllArgValues(OPT_fsanitize_coverage_blocklist);
Opts.SanitizeMemoryTrackOrigins =
getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
Opts.SanitizeMemoryUseAfterDtor = Opts.SanitizeMemoryUseAfterDtor =
Args.hasFlag(OPT_fsanitize_memory_use_after_dtor, Args.hasFlag(OPT_fsanitize_memory_use_after_dtor,
OPT_fno_sanitize_memory_use_after_dtor, OPT_fno_sanitize_memory_use_after_dtor,
false); false);
Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime); Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime);
Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso); Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
Opts.SanitizeCfiICallGeneralizePointers = Opts.SanitizeCfiICallGeneralizePointers =
Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers); Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers);
Show All 14 Linesstatic bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
} }
Opts.SanitizeAddressGlobalsDeadStripping = Opts.SanitizeAddressGlobalsDeadStripping =
Args.hasArg(OPT_fsanitize_address_globals_dead_stripping); Args.hasArg(OPT_fsanitize_address_globals_dead_stripping);
if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_odr_indicator, if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_odr_indicator,
OPT_fno_sanitize_address_use_odr_indicator)) { OPT_fno_sanitize_address_use_odr_indicator)) {
Opts.SanitizeAddressUseOdrIndicator = Opts.SanitizeAddressUseOdrIndicator =
A->getOption().getID() == OPT_fsanitize_address_use_odr_indicator; A->getOption().getID() == OPT_fsanitize_address_use_odr_indicator;
} }
Opts.SSPBufferSize =
getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
Opts.StackProtectorGuard = Opts.StackProtectorGuard =
std::string(Args.getLastArgValue(OPT_mstack_protector_guard_EQ)); std::string(Args.getLastArgValue(OPT_mstack_protector_guard_EQ));
if (Arg *A = Args.getLastArg(OPT_mstack_protector_guard_offset_EQ)) { if (Arg *A = Args.getLastArg(OPT_mstack_protector_guard_offset_EQ)) {
StringRef Val = A->getValue(); StringRef Val = A->getValue();
unsigned Offset = Opts.StackProtectorGuardOffset; unsigned Offset = Opts.StackProtectorGuardOffset;
Val.getAsInteger(10, Offset); Val.getAsInteger(10, Offset);
Opts.StackProtectorGuardOffset = Offset; Opts.StackProtectorGuardOffset = Offset;
} }
Opts.StackProtectorGuardReg = Opts.StackProtectorGuardReg =
std::string(Args.getLastArgValue(OPT_mstack_protector_guard_reg_EQ, std::string(Args.getLastArgValue(OPT_mstack_protector_guard_reg_EQ,
"none")); "none"));
Opts.StackRealignment = Args.hasArg(OPT_mstackrealign); Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
StringRef Val = A->getValue();
unsigned StackAlignment = Opts.StackAlignment;
Val.getAsInteger(10, StackAlignment);
Opts.StackAlignment = StackAlignment;
}
if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) {
StringRef Val = A->getValue();
unsigned StackProbeSize = Opts.StackProbeSize;
Val.getAsInteger(0, StackProbeSize);
Opts.StackProbeSize = StackProbeSize;
}
Opts.NoStackArgProbe = Args.hasArg(OPT_mno_stack_arg_probe); Opts.NoStackArgProbe = Args.hasArg(OPT_mno_stack_arg_probe);
Opts.StackClashProtector = Args.hasArg(OPT_fstack_clash_protection); Opts.StackClashProtector = Args.hasArg(OPT_fstack_clash_protection);
if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
StringRef Name = A->getValue();
unsigned Method = llvm::StringSwitch<unsigned>(Name)
.Case("legacy", CodeGenOptions::Legacy)
.Case("non-legacy", CodeGenOptions::NonLegacy)
.Case("mixed", CodeGenOptions::Mixed)
.Default(~0U);
if (Method == ~0U) {
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
Success = false;
} else {
Opts.setObjCDispatchMethod(
static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
}
}
if (Args.hasArg(OPT_fno_objc_convert_messages_to_runtime_calls)) if (Args.hasArg(OPT_fno_objc_convert_messages_to_runtime_calls))
Opts.ObjCConvertMessagesToRuntimeCalls = 0; Opts.ObjCConvertMessagesToRuntimeCalls = 0;
if (Args.getLastArg(OPT_femulated_tls) || if (Args.getLastArg(OPT_femulated_tls) ||
Args.getLastArg(OPT_fno_emulated_tls)) { Args.getLastArg(OPT_fno_emulated_tls)) {
Opts.ExplicitEmulatedTLS = true; Opts.ExplicitEmulatedTLS = true;
Opts.EmulatedTLS = Opts.EmulatedTLS =
Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false); Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
} }
if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
StringRef Name = A->getValue();
unsigned Model = llvm::StringSwitch<unsigned>(Name)
.Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
.Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
.Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
.Case("local-exec", CodeGenOptions::LocalExecTLSModel)
.Default(~0U);
if (Model == ~0U) {
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
Success = false;
} else {
Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
}
}
Opts.TLSSize = getLastArgIntValue(Args, OPT_mtls_size_EQ, 0, Diags);
if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) { if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
StringRef Val = A->getValue(); StringRef Val = A->getValue();
Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val); Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val);
if (!Opts.FPDenormalMode.isValid()) if (!Opts.FPDenormalMode.isValid())
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val; Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
} }
if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) { if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines else {
Opts.EnableAIXExtendedAltivecABI = 1; Opts.EnableAIXExtendedAltivecABI = 1;
} }
} }
Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib); Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option); Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
bool NeedLocTracking = false; bool NeedLocTracking = false;
Opts.OptRecordFile = std::string(Args.getLastArgValue(OPT_opt_record_file));
if (!Opts.OptRecordFile.empty()) if (!Opts.OptRecordFile.empty())
NeedLocTracking = true; NeedLocTracking = true;
if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) { if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
Opts.OptRecordPasses = A->getValue(); Opts.OptRecordPasses = A->getValue();
NeedLocTracking = true; NeedLocTracking = true;
} }
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesstatic bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
// FIXME: Report unrecoverable sanitizers incorrectly specified here. // FIXME: Report unrecoverable sanitizers incorrectly specified here.
parseSanitizerKinds("-fsanitize-recover=", parseSanitizerKinds("-fsanitize-recover=",
Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags, Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
Opts.SanitizeRecover); Opts.SanitizeRecover);
parseSanitizerKinds("-fsanitize-trap=", parseSanitizerKinds("-fsanitize-trap=",
Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags, Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
Opts.SanitizeTrap); Opts.SanitizeTrap);
Opts.CudaGpuBinaryFileName =
std::string(Args.getLastArgValue(OPT_fcuda_include_gpubinary));
Opts.Backchain = Args.hasArg(OPT_mbackchain); Opts.Backchain = Args.hasArg(OPT_mbackchain);
Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true); Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);
Opts.Addrsig = Args.hasArg(OPT_faddrsig); Opts.Addrsig = Args.hasArg(OPT_faddrsig);
Opts.KeepStaticConsts = Args.hasArg(OPT_fkeep_static_consts); Opts.KeepStaticConsts = Args.hasArg(OPT_fkeep_static_consts);
Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening); Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening);
Opts.DefaultFunctionAttrs = Args.getAllArgValues(OPT_default_function_attr); Opts.DefaultFunctionAttrs = Args.getAllArgValues(OPT_default_function_attr);
Opts.PassPlugins = Args.getAllArgValues(OPT_fpass_plugin_EQ); Opts.PassPlugins = Args.getAllArgValues(OPT_fpass_plugin_EQ);
Opts.SymbolPartition =
std::string(Args.getLastArgValue(OPT_fsymbol_partition_EQ));
Opts.ForceAAPCSBitfieldLoad = Args.hasArg(OPT_ForceAAPCSBitfieldLoad); Opts.ForceAAPCSBitfieldLoad = Args.hasArg(OPT_ForceAAPCSBitfieldLoad);
Opts.AAPCSBitfieldWidth = Opts.AAPCSBitfieldWidth =
Args.hasFlag(OPT_AAPCSBitfieldWidth, OPT_ForceNoAAPCSBitfieldWidth, true); Args.hasFlag(OPT_AAPCSBitfieldWidth, OPT_ForceNoAAPCSBitfieldWidth, true);
Opts.PassByValueIsNoAlias = Args.hasArg(OPT_fpass_by_value_is_noalias); Opts.PassByValueIsNoAlias = Args.hasArg(OPT_fpass_by_value_is_noalias);
return Success; return Success;
} }
▲ Show 20 Lines • Show All 2,234 Lines • ▼ Show 20 Lines if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&
Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false; Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;
Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored); Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
} }
// Store the command-line for using in the CodeView backend. // Store the command-line for using in the CodeView backend.
Res.getCodeGenOpts().Argv0 = Argv0; Res.getCodeGenOpts().Argv0 = Argv0;
Res.getCodeGenOpts().CommandLineArgs = CommandLineArgs; Res.getCodeGenOpts().CommandLineArgs = CommandLineArgs;
FixupInvocation(Res, Diags); FixupInvocation(Res, Diags, Args);
return Success; return Success;
} }
std::string CompilerInvocation::getModuleHash() const { std::string CompilerInvocation::getModuleHash() const {
// Note: For QoI reasons, the things we use as a hash here should all be // Note: For QoI reasons, the things we use as a hash here should all be
// dumped via the -module-info flag. // dumped via the -module-info flag.
using llvm::hash_code; using llvm::hash_code;
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

clang/test/Profile/c-generate.c

// Check that the -fprofile-instrument-path= form works. // Check that the -fprofile-instrument-path= form works.
// RUN: %clang_cc1 -main-file-name c-generate.c %s -o - -emit-llvm -fprofile-instrument=clang -fprofile-instrument-path=c-generate-test.profraw | FileCheck %s --check-prefix=PROF-INSTR-PATH // RUN: %clang_cc1 -main-file-name c-generate.c %s -o - -emit-llvm -fprofile-instrument=clang -fprofile-instrument-path=c-generate-test.profraw | FileCheck %s --check-prefix=PROF-INSTR-PATH
// RUN: %clang_cc1 %s -o - -emit-llvm -fprofile-instrument=none | FileCheck %s --check-prefix=PROF-INSTR-NONE // RUN: %clang_cc1 %s -o - -emit-llvm -fprofile-instrument=none | FileCheck %s --check-prefix=PROF-INSTR-NONE
// RUN: not %clang_cc1 %s -o - -emit-llvm -fprofile-instrument=garbage 2>&1 | FileCheck %s --check-prefix=PROF-INSTR-GARBAGE // RUN: not %clang_cc1 %s -o - -emit-llvm -fprofile-instrument=garbage 2>&1 | FileCheck %s --check-prefix=PROF-INSTR-GARBAGE
// //
// PROF-INSTR-PATH: constant [24 x i8] c"c-generate-test.profraw\00" // PROF-INSTR-PATH: constant [24 x i8] c"c-generate-test.profraw\00"
// //
// PROF-INSTR-NONE-NOT: __llvm_prf // PROF-INSTR-NONE-NOT: __llvm_prf
// //
// PROF-INSTR-GARBAGE: invalid PGO instrumentor in argument '-fprofile-instrument=garbage' // PROF-INSTR-GARBAGE: invalid value 'garbage' in '-fprofile-instrument=garbage'
int main(void) { int main(void) {
return 0; return 0;
} }