29#include "clang/Config/config.h"
48#include "llvm/ADT/APInt.h"
49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/CachedHashString.h"
51#include "llvm/ADT/DenseSet.h"
52#include "llvm/ADT/FloatingPointMode.h"
53#include "llvm/ADT/Hashing.h"
54#include "llvm/ADT/STLExtras.h"
55#include "llvm/ADT/SmallString.h"
56#include "llvm/ADT/SmallVector.h"
57#include "llvm/ADT/StringRef.h"
58#include "llvm/ADT/StringSwitch.h"
59#include "llvm/ADT/Twine.h"
60#include "llvm/Config/llvm-config.h"
61#include "llvm/Frontend/Debug/Options.h"
62#include "llvm/IR/DebugInfoMetadata.h"
63#include "llvm/Linker/Linker.h"
64#include "llvm/MC/MCTargetOptions.h"
65#include "llvm/Option/Arg.h"
66#include "llvm/Option/ArgList.h"
67#include "llvm/Option/OptSpecifier.h"
68#include "llvm/Option/OptTable.h"
69#include "llvm/Option/Option.h"
70#include "llvm/ProfileData/InstrProfReader.h"
71#include "llvm/Remarks/HotnessThresholdParser.h"
72#include "llvm/Support/CodeGen.h"
73#include "llvm/Support/Compiler.h"
74#include "llvm/Support/Error.h"
75#include "llvm/Support/ErrorHandling.h"
76#include "llvm/Support/ErrorOr.h"
77#include "llvm/Support/FileSystem.h"
78#include "llvm/Support/HashBuilder.h"
79#include "llvm/Support/MathExtras.h"
80#include "llvm/Support/MemoryBuffer.h"
81#include "llvm/Support/Path.h"
82#include "llvm/Support/Process.h"
83#include "llvm/Support/Regex.h"
84#include "llvm/Support/VersionTuple.h"
85#include "llvm/Support/VirtualFileSystem.h"
86#include "llvm/Support/raw_ostream.h"
87#include "llvm/Target/TargetOptions.h"
88#include "llvm/TargetParser/Host.h"
89#include "llvm/TargetParser/Triple.h"
102#include <type_traits>
106using namespace clang;
107using namespace driver;
108using namespace options;
119 if (Arg.getAsInteger(10, Val))
120 return llvm::createStringError(llvm::inconvertibleErrorCode(),
121 "Not an integer: %s", Arg.data());
168#define SIMPLE_ENUM_VALUE_TABLE
169#include "clang/Driver/Options.inc"
170#undef SIMPLE_ENUM_VALUE_TABLE
176 if (Args.hasArg(Opt))
185 if (Args.hasArg(Opt))
195 const char *Spelling,
197 Option::OptionClass,
unsigned, ...) {
198 Args.push_back(Spelling);
202 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
206 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
208 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
210 if (Args.hasArg(Opt))
217 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
223 OptSpecifier OtherOpt) {
224 return [
Value, OtherValue,
225 OtherOpt](OptSpecifier Opt,
unsigned,
const ArgList &Args,
227 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
228 return A->getOption().matches(Opt) ?
Value : OtherValue;
238 if (KeyPath ==
Value)
239 Args.push_back(Spelling);
244 const char *Spelling,
246 Option::OptionClass OptClass,
unsigned,
247 const Twine &
Value) {
249 case Option::SeparateClass:
250 case Option::JoinedOrSeparateClass:
251 case Option::JoinedAndSeparateClass:
252 Args.push_back(Spelling);
253 Args.push_back(SA(
Value));
255 case Option::JoinedClass:
256 case Option::CommaJoinedClass:
257 Args.push_back(SA(Twine(Spelling) +
Value));
260 llvm_unreachable(
"Cannot denormalize an option with option class "
261 "incompatible with string denormalization.");
269 Option::OptionClass OptClass,
unsigned TableIndex, T
Value) {
273static std::optional<SimpleEnumValue>
275 for (
int I = 0, E = Table.Size; I != E; ++I)
276 if (Name == Table.Table[I].Name)
277 return Table.Table[I];
282static std::optional<SimpleEnumValue>
284 for (
int I = 0, E = Table.Size; I != E; ++I)
285 if (
Value == Table.Table[I].Value)
286 return Table.Table[I];
295 assert(TableIndex < SimpleEnumValueTablesSize);
296 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
298 auto *Arg = Args.getLastArg(Opt);
302 StringRef ArgValue = Arg->getValue();
304 return MaybeEnumVal->Value;
306 Diags.
Report(diag::err_drv_invalid_value)
307 << Arg->getAsString(Args) << ArgValue;
312 const char *Spelling,
314 Option::OptionClass OptClass,
315 unsigned TableIndex,
unsigned Value) {
316 assert(TableIndex < SimpleEnumValueTablesSize);
317 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
322 llvm_unreachable(
"The simple enum value was not correctly defined in "
323 "the tablegen option description");
329 const char *Spelling,
331 Option::OptionClass OptClass,
332 unsigned TableIndex, T
Value) {
334 static_cast<unsigned>(
Value));
341 auto *Arg = Args.getLastArg(Opt);
344 return std::string(Arg->getValue());
347template <
typename IntTy>
351 auto *Arg = Args.getLastArg(Opt);
355 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
356 Diags.
Report(diag::err_drv_invalid_int_value)
357 << Arg->getAsString(Args) << Arg->getValue();
363static std::optional<std::vector<std::string>>
366 return Args.getAllArgValues(Opt);
370 const char *Spelling,
372 Option::OptionClass OptClass,
374 const std::vector<std::string> &Values) {
376 case Option::CommaJoinedClass: {
377 std::string CommaJoinedValue;
378 if (!Values.empty()) {
379 CommaJoinedValue.append(Values.front());
380 for (
const std::string &
Value : llvm::drop_begin(Values, 1)) {
381 CommaJoinedValue.append(
",");
382 CommaJoinedValue.append(
Value);
386 TableIndex, CommaJoinedValue);
389 case Option::JoinedClass:
390 case Option::SeparateClass:
391 case Option::JoinedOrSeparateClass:
392 for (
const std::string &
Value : Values)
396 llvm_unreachable(
"Cannot denormalize an option with option class "
397 "incompatible with string vector denormalization.");
405 auto *Arg = Args.getLastArg(Opt);
408 return llvm::Triple::normalize(Arg->getValue());
411template <
typename T,
typename U>
413 return static_cast<T
>(
Value);
417 return KeyPath |
Value;
424template <
typename T,
typename U, U Value>
429#define PARSE_OPTION_WITH_MARSHALLING( \
430 ARGS, DIAGS, PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, \
431 PARAM, HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, \
432 KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
433 DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
434 if ((FLAGS)&options::CC1Option) { \
435 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
437 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
439 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
441 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
446#define GENERATE_OPTION_WITH_MARSHALLING( \
447 ARGS, STRING_ALLOCATOR, PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, \
448 ALIASARGS, FLAGS, PARAM, HELPTEXT, METAVAR, VALUES, SPELLING, \
449 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
450 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
451 if ((FLAGS)&options::CC1Option) { \
452 [&](const auto &Extracted) { \
455 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
456 : (DEFAULT_VALUE)))) \
457 DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class, \
458 TABLE_INDEX, Extracted); \
459 }(EXTRACTOR(KEYPATH)); \
473 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
474 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
475 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
476 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
479 CodeGenOpts.ClearASTBeforeBackend =
false;
481 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
482 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
485 llvm::Triple T(TargetOpts.
Triple);
486 llvm::Triple::ArchType Arch = T.getArch();
490 if (LangOpts.getExceptionHandling() !=
492 T.isWindowsMSVCEnvironment())
493 Diags.
Report(diag::err_fe_invalid_exception_model)
494 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str();
496 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
497 Diags.
Report(diag::warn_c_kext);
499 if (LangOpts.NewAlignOverride &&
500 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
501 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
502 Diags.
Report(diag::err_fe_invalid_alignment)
503 << A->getAsString(Args) << A->getValue();
504 LangOpts.NewAlignOverride = 0;
508 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
509 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
512 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
513 Diags.
Report(diag::err_drv_argument_not_allowed_with)
516 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
517 Diags.
Report(diag::err_drv_argument_not_allowed_with)
520 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
521 Diags.
Report(diag::warn_ignored_hip_only_option)
522 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
524 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
525 Diags.
Report(diag::warn_ignored_hip_only_option)
526 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
535 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
536 if (LangOpts.ApproxFunc)
537 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
538 if (LangOpts.AllowFPReassoc)
539 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
540 if (LangOpts.AllowRecip)
541 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
547 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
549 Diags.
Report(diag::warn_option_invalid_ocl_version)
551 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
553 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
554 auto DefaultCC = LangOpts.getDefaultCallingConv();
558 Arch != llvm::Triple::x86;
563 Diags.
Report(diag::err_drv_argument_not_allowed_with)
564 << A->getSpelling() << T.getTriple();
576 unsigned DefaultOpt = llvm::CodeGenOpt::None;
579 !Args.hasArg(OPT_cl_opt_disable))
580 DefaultOpt = llvm::CodeGenOpt::Default;
582 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
583 if (A->getOption().matches(options::OPT_O0))
584 return llvm::CodeGenOpt::None;
586 if (A->getOption().matches(options::OPT_Ofast))
587 return llvm::CodeGenOpt::Aggressive;
589 assert(A->getOption().matches(options::OPT_O));
591 StringRef S(A->getValue());
592 if (S ==
"s" || S ==
"z")
593 return llvm::CodeGenOpt::Default;
596 return llvm::CodeGenOpt::Less;
605 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
606 if (A->getOption().matches(options::OPT_O)) {
607 switch (A->getValue()[0]) {
621 llvm::opt::OptSpecifier OptSpecifier,
625 Option::OptionClass::FlagClass, 0);
629 llvm::opt::OptSpecifier OptSpecifier,
634 Opt.getKind(), 0,
Value);
670 bool CheckAgainstOriginalInvocation =
false,
671 bool ForceRoundTrip =
false) {
673 bool DoRoundTripDefault =
true;
675 bool DoRoundTripDefault =
false;
678 bool DoRoundTrip = DoRoundTripDefault;
679 if (ForceRoundTrip) {
682 for (
const auto *Arg : CommandLineArgs) {
683 if (Arg == StringRef(
"-round-trip-args"))
685 if (Arg == StringRef(
"-no-round-trip-args"))
693 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
698 llvm::raw_string_ostream
OS(Buffer);
699 for (
const char *Arg : Args) {
700 llvm::sys::printArg(
OS, Arg,
true);
713 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
720 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
726 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
727 Diags.
Report(diag::note_cc1_round_trip_original)
728 << SerializeArgs(CommandLineArgs);
733 llvm::BumpPtrAllocator Alloc;
734 llvm::StringSaver StringPool(Alloc);
735 auto SA = [&StringPool](
const Twine &Arg) {
736 return StringPool.save(Arg).data();
743 Generate(DummyInvocation, GeneratedArgs, SA);
749 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
754 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
755 Diags.
Report(diag::note_cc1_round_trip_generated)
756 << 1 << SerializeArgs(GeneratedArgs);
761 if (CheckAgainstOriginalInvocation)
763 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
767 Generate(RealInvocation, ComparisonArgs, SA);
772 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
773 [](
const char *AElem,
const char *BElem) {
774 return StringRef(AElem) == StringRef(BElem);
781 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
782 Diags.
Report(diag::err_cc1_round_trip_mismatch);
783 Diags.
Report(diag::note_cc1_round_trip_generated)
784 << 1 << SerializeArgs(GeneratedArgs);
785 Diags.
Report(diag::note_cc1_round_trip_generated)
786 << 2 << SerializeArgs(ComparisonArgs);
790 Diags.
Report(diag::remark_cc1_round_trip_generated)
791 << 1 << SerializeArgs(GeneratedArgs);
792 Diags.
Report(diag::remark_cc1_round_trip_generated)
793 << 2 << SerializeArgs(ComparisonArgs);
805 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
809 Args.push_back(
"-cc1");
812 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
817 OptSpecifier GroupWithValue,
818 std::vector<std::string> &Diagnostics) {
819 for (
auto *A : Args.filtered(Group)) {
820 if (A->getOption().getKind() == Option::FlagClass) {
823 Diagnostics.push_back(
824 std::string(A->getOption().getName().drop_front(1)));
825 }
else if (A->getOption().matches(GroupWithValue)) {
828 Diagnostics.push_back(
829 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
832 Diagnostics.push_back(A->getValue());
843 std::vector<std::string> &Funcs) {
844 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
846 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
854#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
855 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
856#include "clang/Driver/Options.inc"
857#undef ANALYZER_OPTION_WITH_MARSHALLING
861#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
863 GenerateArg(Args, OPT_analyzer_constraints, CMDFLAG, SA); \
865#include "clang/StaticAnalyzer/Core/Analyses.def"
867 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
873#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
875 GenerateArg(Args, OPT_analyzer_output, CMDFLAG, SA); \
877#include "clang/StaticAnalyzer/Core/Analyses.def"
879 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
885#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
887 GenerateArg(Args, OPT_analyzer_purge, CMDFLAG, SA); \
889#include "clang/StaticAnalyzer/Core/Analyses.def"
891 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
897#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
899 GenerateArg(Args, OPT_analyzer_inlining_mode, CMDFLAG, SA); \
901#include "clang/StaticAnalyzer/Core/Analyses.def"
903 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
909 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
918 for (
const auto &
C : Opts.
Config)
919 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
920 llvm::sort(SortedConfigOpts, llvm::less_first());
922 for (
const auto &[Key,
Value] : SortedConfigOpts) {
925 auto Entry = ConfigOpts.
Config.find(Key);
926 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
941#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
942 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
943#include "clang/Driver/Options.inc"
944#undef ANALYZER_OPTION_WITH_MARSHALLING
946 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
947 StringRef Name = A->getValue();
949#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
950 .Case(CMDFLAG, NAME##Model)
951#include "clang/StaticAnalyzer/Core/Analyses.def"
954 Diags.
Report(diag::err_drv_invalid_value)
955 << A->getAsString(Args) << Name;
958 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
959 Diags.
Report(diag::err_analyzer_not_built_with_z3);
966 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
967 StringRef Name = A->getValue();
969#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
970 .Case(CMDFLAG, PD_##NAME)
971#include "clang/StaticAnalyzer/Core/Analyses.def"
974 Diags.
Report(diag::err_drv_invalid_value)
975 << A->getAsString(Args) << Name;
981 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
982 StringRef Name = A->getValue();
984#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
986#include "clang/StaticAnalyzer/Core/Analyses.def"
989 Diags.
Report(diag::err_drv_invalid_value)
990 << A->getAsString(Args) << Name;
996 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
997 StringRef Name = A->getValue();
999#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1000 .Case(CMDFLAG, NAME)
1001#include "clang/StaticAnalyzer/Core/Analyses.def"
1004 Diags.
Report(diag::err_drv_invalid_value)
1005 << A->getAsString(Args) << Name;
1013 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1015 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1018 StringRef CheckerAndPackageList = A->getValue();
1020 CheckerAndPackageList.split(CheckersAndPackages,
",");
1021 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1027 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1031 StringRef configList = A->getValue();
1033 configList.split(configVals,
",");
1034 for (
const auto &configVal : configVals) {
1036 std::tie(key, val) = configVal.split(
"=");
1039 diag::err_analyzer_config_no_value) << configVal;
1042 if (val.contains(
'=')) {
1044 diag::err_analyzer_config_multiple_values)
1053 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1058 Opts.
Config[key] = std::string(val);
1061 constexpr auto SingleFAM =
1062 "consider-single-element-arrays-as-flexible-array-members";
1063 if (key == SingleFAM) {
1064 Diags.
Report(diag::warn_analyzer_deprecated_option_with_alternative)
1065 << SingleFAM <<
"clang-17"
1066 <<
"-fstrict-flex-arrays=<N>";
1077 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1080 os << Args.getArgString(i);
1088 StringRef OptionName, StringRef DefaultVal) {
1089 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1094 StringRef &OptionField, StringRef Name,
1095 StringRef DefaultVal) {
1104 bool &OptionField, StringRef Name,
bool DefaultVal) {
1105 auto PossiblyInvalidVal =
1106 llvm::StringSwitch<std::optional<bool>>(
1109 .Case(
"false",
false)
1110 .Default(std::nullopt);
1112 if (!PossiblyInvalidVal) {
1114 Diags->
Report(diag::err_analyzer_config_invalid_input)
1115 << Name <<
"a boolean";
1117 OptionField = DefaultVal;
1119 OptionField = *PossiblyInvalidVal;
1124 unsigned &OptionField, StringRef Name,
1125 unsigned DefaultVal) {
1127 OptionField = DefaultVal;
1128 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1129 .getAsInteger(0, OptionField);
1130 if (Diags && HasFailed)
1131 Diags->
Report(diag::err_analyzer_config_invalid_input)
1132 << Name <<
"an unsigned";
1140#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1141 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1142#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1143#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1145 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1146 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1148#define ANALYZER_OPTION(...)
1149#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1150 SHALLOW_VAL, DEEP_VAL) \
1151 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1152 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1153#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1160 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1161 std::vector<StringRef> Checkers =
1163 std::vector<StringRef> Packages =
1167 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1169 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1171 bool IsChecker = CheckerOrPackage.contains(
'.');
1172 bool IsValidName = IsChecker
1173 ? llvm::is_contained(Checkers, CheckerOrPackage)
1174 : llvm::is_contained(Packages, CheckerOrPackage);
1177 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1178 << CheckerOrPackage;
1188 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1189 Diags->
Report(diag::err_analyzer_config_invalid_input)
1190 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1192 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1193 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1196 if (!AnOpts.ModelPath.empty() &&
1197 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1198 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1206 OptSpecifier OptEQ, StringRef Name,
1208 if (
Remark.hasValidPattern()) {
1213 GenerateArg(Args, OPT_R_Joined, StringRef(
"no-") + Name, SA);
1222 OptSpecifier OptEQ, StringRef Name) {
1225 auto InitializeResultPattern = [&Diags, &Args, &
Result](
const Arg *A,
1226 StringRef Pattern) {
1227 Result.Pattern = Pattern.str();
1229 std::string RegexError;
1230 Result.Regex = std::make_shared<llvm::Regex>(
Result.Pattern);
1231 if (!
Result.Regex->isValid(RegexError)) {
1232 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1233 << RegexError << A->getAsString(Args);
1240 for (Arg *A : Args) {
1241 if (A->getOption().matches(OPT_R_Joined)) {
1242 StringRef
Value = A->getValue();
1246 else if (
Value ==
"everything")
1248 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1250 else if (
Value ==
"no-everything")
1260 InitializeResultPattern(A,
".*");
1262 }
else if (A->getOption().matches(OptEQ)) {
1264 if (!InitializeResultPattern(A, A->getValue()))
1273 const std::vector<std::string> &Levels,
1276 bool Success =
true;
1277 for (
const auto &Level : Levels) {
1279 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1287 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1295 const std::vector<std::string> &Sanitizers,
1297 for (
const auto &Sanitizer : Sanitizers) {
1300 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1316 llvm::SplitString(Bundle, BundleParts,
",");
1317 for (
const auto &B : BundleParts) {
1321 D.
Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1335 llvm::raw_string_ostream
OS(Buffer);
1336 llvm::interleave(BundleParts,
OS, [&
OS](StringRef Part) {
OS << Part; },
",");
1342 const Twine &ProfileName,
1343 llvm::vfs::FileSystem &FS,
1345 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);
1346 if (
auto E = ReaderOrErr.takeError()) {
1348 "Error in reading profile %0: %1");
1349 llvm::handleAllErrors(std::move(E), [&](
const llvm::ErrorInfoBase &EI) {
1350 Diags.
Report(DiagID) << ProfileName.str() << EI.message();
1354 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1355 std::move(ReaderOrErr.get());
1359 if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1360 if (PGOReader->hasCSIRLevelProfile())
1368void CompilerInvocation::GenerateCodeGenArgs(
1370 StringAllocator SA,
const llvm::Triple &T,
const std::string &OutputFile,
1374 if (Opts.OptimizationLevel == 0)
1377 GenerateArg(Args, OPT_O, Twine(Opts.OptimizationLevel), SA);
1379#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1380 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
1381#include "clang/Driver/Options.inc"
1382#undef CODEGEN_OPTION_WITH_MARSHALLING
1384 if (Opts.OptimizationLevel > 0) {
1388 GenerateArg(Args, OPT_finline_hint_functions, SA);
1393 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1394 GenerateArg(Args, OPT_fdirect_access_external_data, SA);
1395 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1396 GenerateArg(Args, OPT_fno_direct_access_external_data, SA);
1398 std::optional<StringRef> DebugInfoVal;
1399 switch (Opts.DebugInfo) {
1400 case llvm::codegenoptions::DebugLineTablesOnly:
1401 DebugInfoVal =
"line-tables-only";
1403 case llvm::codegenoptions::DebugDirectivesOnly:
1404 DebugInfoVal =
"line-directives-only";
1406 case llvm::codegenoptions::DebugInfoConstructor:
1407 DebugInfoVal =
"constructor";
1409 case llvm::codegenoptions::LimitedDebugInfo:
1410 DebugInfoVal =
"limited";
1412 case llvm::codegenoptions::FullDebugInfo:
1413 DebugInfoVal =
"standalone";
1415 case llvm::codegenoptions::UnusedTypeInfo:
1416 DebugInfoVal =
"unused-types";
1418 case llvm::codegenoptions::NoDebugInfo:
1419 DebugInfoVal = std::nullopt;
1421 case llvm::codegenoptions::LocTrackingOnly:
1422 DebugInfoVal = std::nullopt;
1426 GenerateArg(Args, OPT_debug_info_kind_EQ, *DebugInfoVal, SA);
1430 Prefix.first +
"=" + Prefix.second, SA);
1434 Prefix.first +
"=" + Prefix.second, SA);
1436 if (Opts.NewStructPathTBAA)
1439 if (Opts.OptimizeSize == 1)
1441 else if (Opts.OptimizeSize == 2)
1449 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1451 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1457 if (Opts.DebugNameTable ==
1458 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1460 else if (Opts.DebugNameTable ==
1461 static_cast<unsigned>(
1462 llvm::DICompileUnit::DebugNameTableKind::Default))
1465 auto TNK = Opts.getDebugSimpleTemplateNames();
1466 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1467 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1468 GenerateArg(Args, OPT_gsimple_template_names_EQ,
"simple", SA);
1469 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1470 GenerateArg(Args, OPT_gsimple_template_names_EQ,
"mangled", SA);
1475 if (Opts.TimePasses) {
1476 if (Opts.TimePassesPerRun)
1477 GenerateArg(Args, OPT_ftime_report_EQ,
"per-pass-run", SA);
1482 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1485 if (Opts.PrepareForThinLTO)
1494 StringRef MemProfileBasename(
"memprof.profraw");
1515 std::string InstrBundle =
1517 if (!InstrBundle.empty())
1518 GenerateArg(Args, OPT_fxray_instrumentation_bundle, InstrBundle, SA);
1521 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1522 GenerateArg(Args, OPT_fcf_protection_EQ,
"full", SA);
1523 else if (Opts.CFProtectionReturn)
1524 GenerateArg(Args, OPT_fcf_protection_EQ,
"return", SA);
1525 else if (Opts.CFProtectionBranch)
1526 GenerateArg(Args, OPT_fcf_protection_EQ,
"branch", SA);
1528 if (Opts.FunctionReturnThunks)
1529 GenerateArg(Args, OPT_mfunction_return_EQ,
"thunk-extern", SA);
1532 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1533 F.PropagateAttrs && F.Internalize;
1535 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1540 Args, Opts.EmulatedTLS ? OPT_femulated_tls : OPT_fno_emulated_tls, SA);
1552 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1556 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1560 if (Opts.EnableAIXExtendedAltivecABI)
1578 GenerateArg(Args, OPT_fdiagnostics_hotness_threshold_EQ,
1584 GenerateArg(Args, OPT_fdiagnostics_misexpect_tolerance_EQ,
1588 GenerateArg(Args, OPT_fsanitize_recover_EQ, Sanitizer, SA);
1591 GenerateArg(Args, OPT_fsanitize_trap_EQ, Sanitizer, SA);
1593 if (!Opts.EmitVersionIdentMetadata)
1596 switch (Opts.FiniteLoops) {
1608bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1611 const llvm::Triple &T,
1612 const std::string &OutputFile,
1618 unsigned MaxOptLevel = 3;
1619 if (OptimizationLevel > MaxOptLevel) {
1622 Diags.
Report(diag::warn_drv_optimization_value)
1623 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1624 OptimizationLevel = MaxOptLevel;
1626 Opts.OptimizationLevel = OptimizationLevel;
1635#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1636 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1637#include "clang/Driver/Options.inc"
1638#undef CODEGEN_OPTION_WITH_MARSHALLING
1642 if (Opts.OptimizationLevel == 0) {
1644 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1645 options::OPT_finline_hint_functions,
1646 options::OPT_fno_inline_functions,
1647 options::OPT_fno_inline)) {
1650 if (A->getOption().matches(options::OPT_finline_functions))
1652 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1662 Opts.DirectAccessExternalData =
1663 Args.hasArg(OPT_fdirect_access_external_data) ||
1664 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1667 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1669 llvm::StringSwitch<unsigned>(A->getValue())
1670 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1671 .Case(
"line-directives-only",
1672 llvm::codegenoptions::DebugDirectivesOnly)
1673 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1674 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1675 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1676 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1679 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1682 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1688 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1689 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1690 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1691 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1692 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1693 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1694 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1697 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1698 auto Split = StringRef(Arg).split(
'=');
1700 {std::string(
Split.first), std::string(
Split.second)});
1703 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1704 auto Split = StringRef(Arg).split(
'=');
1706 {std::string(
Split.first), std::string(
Split.second)});
1709 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1710 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1711 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1712 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1715 llvm::is_contained(DebugEntryValueArchs, T.getArch()))
1716 Opts.EmitCallSiteInfo =
true;
1719 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1724 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1725 Args.hasArg(OPT_new_struct_path_tbaa);
1727 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1728 if (Opts.SimplifyLibCalls)
1731 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1732 (Opts.OptimizationLevel > 1));
1734 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1736 Opts.DebugNameTable =
static_cast<unsigned>(
1737 Args.hasArg(OPT_ggnu_pubnames)
1738 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1739 : Args.hasArg(OPT_gpubnames)
1740 ? llvm::DICompileUnit::DebugNameTableKind::Default
1741 : llvm::DICompileUnit::DebugNameTableKind::None);
1742 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1743 StringRef
Value = A->getValue();
1745 Diags.
Report(diag::err_drv_unsupported_option_argument)
1746 << A->getSpelling() << A->getValue();
1747 Opts.setDebugSimpleTemplateNames(
1748 StringRef(A->getValue()) ==
"simple"
1749 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
1750 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
1753 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1754 Opts.TimePasses =
true;
1757 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1758 StringRef Val = A->getValue();
1759 if (Val ==
"per-pass")
1760 Opts.TimePassesPerRun =
false;
1761 else if (Val ==
"per-pass-run")
1762 Opts.TimePassesPerRun =
true;
1764 Diags.
Report(diag::err_drv_invalid_value)
1765 << A->getAsString(Args) << A->getValue();
1769 Opts.PrepareForLTO =
false;
1770 Opts.PrepareForThinLTO =
false;
1771 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1772 Opts.PrepareForLTO =
true;
1773 StringRef S = A->getValue();
1775 Opts.PrepareForThinLTO =
true;
1776 else if (S !=
"full")
1777 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1779 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1781 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1782 << A->getAsString(Args) <<
"-x ir";
1784 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1786 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1788 llvm::StringSwitch<std::string>(A->getValue())
1789 .Case(
"obj", OutputFile)
1790 .Default(llvm::sys::path::filename(OutputFile).str());
1793 const char *MemProfileBasename =
"memprof.profraw";
1794 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1796 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1797 llvm::sys::path::append(Path, MemProfileBasename);
1799 }
else if (Args.hasArg(OPT_fmemory_profile))
1803 if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
1804 if (Args.hasArg(OPT_coverage_version_EQ)) {
1805 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1806 if (CoverageVersion.size() != 4) {
1807 Diags.
Report(diag::err_drv_invalid_value)
1808 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1818 for (
const auto &A : Args) {
1820 if (A->getOption().getID() == options::OPT_o ||
1821 A->getOption().getID() == options::OPT_INPUT ||
1822 A->getOption().getID() == options::OPT_x ||
1823 A->getOption().getID() == options::OPT_fembed_bitcode ||
1824 A->getOption().matches(options::OPT_W_Group))
1827 A->render(Args, ASL);
1828 for (
const auto &arg : ASL) {
1829 StringRef ArgStr(arg);
1830 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1836 auto XRayInstrBundles =
1837 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1838 if (XRayInstrBundles.empty())
1841 for (
const auto &A : XRayInstrBundles)
1845 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1846 StringRef Name = A->getValue();
1847 if (Name ==
"full") {
1848 Opts.CFProtectionReturn = 1;
1849 Opts.CFProtectionBranch = 1;
1850 }
else if (Name ==
"return")
1851 Opts.CFProtectionReturn = 1;
1852 else if (Name ==
"branch")
1853 Opts.CFProtectionBranch = 1;
1854 else if (Name !=
"none")
1855 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1858 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
1859 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
1860 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
1861 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
1862 .Default(llvm::FunctionReturnThunksKind::Invalid);
1865 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1866 << A->getSpelling() << T.getTriple();
1867 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
1868 Diags.
Report(diag::err_drv_invalid_value)
1869 << A->getAsString(Args) << A->getValue();
1870 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
1871 Args.getLastArgValue(OPT_mcmodel_EQ).equals(
"large"))
1872 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1873 << A->getAsString(Args)
1874 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
1876 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
1880 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1883 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1884 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1893 if (!Args.getLastArg(OPT_femulated_tls) &&
1894 !Args.getLastArg(OPT_fno_emulated_tls)) {
1895 Opts.EmulatedTLS = T.hasDefaultEmulatedTLS();
1898 if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
1900 StringRef Name = A->getValue();
1901 if (Name !=
"global-dynamic")
1902 Diags.
Report(diag::err_aix_unsupported_tls_model) << Name;
1906 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1907 StringRef Val = A->getValue();
1911 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1914 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
1915 StringRef Val = A->getValue();
1918 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1924 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
1925 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
1929 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
1930 << A->getSpelling() << T.str();
1932 const Option &O = A->getOption();
1933 if (O.matches(OPT_fpcc_struct_return) ||
1934 O.matches(OPT_maix_struct_return)) {
1937 assert(O.matches(OPT_freg_struct_return) ||
1938 O.matches(OPT_msvr4_struct_return));
1944 Args.getLastArg(OPT_mabi_EQ_vec_default, OPT_mabi_EQ_vec_extabi)) {
1946 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
1947 << A->getSpelling() << T.str();
1949 const Option &O = A->getOption();
1950 Opts.EnableAIXExtendedAltivecABI = O.matches(OPT_mabi_EQ_vec_extabi);
1953 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
1954 if (!T.isOSAIX() || T.isPPC32())
1955 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
1956 << A->getSpelling() << T.str();
1959 bool NeedLocTracking =
false;
1962 NeedLocTracking =
true;
1964 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
1966 NeedLocTracking =
true;
1969 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
1971 NeedLocTracking =
true;
1981 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
1991 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
1994 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1995 <<
"-fdiagnostics-show-hotness";
1999 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2001 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2004 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2005 <<
"-fdiagnostics-hotness-threshold=";
2011 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2012 <<
"-fdiagnostics-hotness-threshold=";
2017 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2021 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2022 <<
"-fdiagnostics-misexpect-tolerance=";
2028 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2029 <<
"-fdiagnostics-misexpect-tolerance=";
2036 if (UsingSampleProfile)
2037 NeedLocTracking =
true;
2040 NeedLocTracking =
true;
2044 if (NeedLocTracking &&
2045 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2046 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2051 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2054 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2057 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2059 if (Args.hasArg(options::OPT_ffinite_loops))
2061 else if (Args.hasArg(options::OPT_fno_finite_loops))
2064 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2065 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2066 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2067 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2077#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2078 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
2079#include "clang/Driver/Options.inc"
2080#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2085 for (
const auto &Dep : Opts.
ExtraDeps) {
2086 switch (Dep.second) {
2099 GenerateArg(Args, OPT_fdepfile_entry, Dep.first, SA);
2108 bool ShowLineMarkers) {
2112#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2113 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2114#include "clang/Driver/Options.inc"
2115#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2117 if (Args.hasArg(OPT_show_includes)) {
2132 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2133 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2134 StringRef Val = A->getValue();
2135 if (!Val.contains(
'='))
2139 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2140 StringRef Val = A->getValue();
2141 if (!Val.contains(
'='))
2148 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2152 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2156 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2157 StringRef Val = A->getValue();
2158 if (!Val.contains(
'='))
2168 Diags.
Report(diag::err_drv_print_header_env_var_combination_cc1)
2169 << Args.getLastArg(OPT_header_include_format_EQ)->getValue()
2170 << Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();
2184 }
ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2185 for (
auto *A : Args) {
2186 const Option &O = A->getOption();
2187 if (O.matches(options::OPT_fcolor_diagnostics)) {
2189 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2191 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2192 StringRef
Value(A->getValue());
2193 if (
Value ==
"always")
2195 else if (
Value ==
"never")
2197 else if (
Value ==
"auto")
2203 llvm::sys::Process::StandardErrHasColors());
2208 bool Success =
true;
2209 for (
const auto &Prefix : VerifyPrefixes) {
2212 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2215 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2217 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2218 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2229#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2230 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
2231#include "clang/Driver/Options.inc"
2232#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2241#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2242 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2243#include "clang/Driver/Options.inc"
2244#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2253#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2254 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
2255#include "clang/Driver/Options.inc"
2256#undef MIGRATOR_OPTION_WITH_MARSHALLING
2265#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2266 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2267#include "clang/Driver/Options.inc"
2268#undef MIGRATOR_OPTION_WITH_MARSHALLING
2273void CompilerInvocation::GenerateDiagnosticArgs(
2275 StringAllocator SA,
bool DefaultDiagColor) {
2277#define DIAG_OPTION_WITH_MARSHALLING(...) \
2278 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
2279#include "clang/Driver/Options.inc"
2280#undef DIAG_OPTION_WITH_MARSHALLING
2286 if (Opts.ShowColors)
2289 if (Opts.VerifyDiagnostics &&
2294 if (Prefix !=
"expected")
2301 GenerateArg(Args, OPT_verify_ignore_unexpected, SA);
2304 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"note", SA);
2306 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"remark", SA);
2308 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"warning", SA);
2310 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"error", SA);
2315 if (
Warning ==
"undef-prefix")
2317 Args.push_back(SA(StringRef(
"-W") +
Warning));
2323 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2324 "pass-analysis",
"no-pass-analysis",
2325 "pass-missed",
"no-pass-missed"};
2326 if (llvm::is_contained(IgnoredRemarks,
Remark))
2329 Args.push_back(SA(StringRef(
"-R") +
Remark));
2333std::unique_ptr<DiagnosticOptions>
2335 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2336 unsigned MissingArgIndex, MissingArgCount;
2338 Argv.slice(1), MissingArgIndex, MissingArgCount);
2348 bool DefaultDiagColor) {
2349 std::optional<DiagnosticsEngine> IgnoringDiags;
2353 Diags = &*IgnoringDiags;
2362#define DIAG_OPTION_WITH_MARSHALLING(...) \
2363 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2364#include "clang/Driver/Options.inc"
2365#undef DIAG_OPTION_WITH_MARSHALLING
2367 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2370 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2374 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2376 if (Args.hasArg(OPT_verify))
2381 Opts.VerifyDiagnostics =
false;
2386 "-verify-ignore-unexpected=",
2387 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2388 if (Args.hasArg(OPT_verify_ignore_unexpected))
2390 Opts.setVerifyIgnoreUnexpected(DiagMask);
2393 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2408 std::string &BlockName,
2409 unsigned &MajorVersion,
2410 unsigned &MinorVersion,
2412 std::string &UserInfo) {
2414 Arg.split(Args,
':', 5);
2415 if (Args.size() < 5)
2418 BlockName = std::string(Args[0]);
2419 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2420 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2421 if (Args[3].getAsInteger(2, Hashed))
return true;
2422 if (Args.size() > 4)
2423 UserInfo = std::string(Args[4]);
2432 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2478 OPT_print_dependency_directives_minimized_source},
2485static std::optional<frontend::ActionKind>
2488 if (ActionOpt.second == Opt.getID())
2489 return ActionOpt.first;
2491 return std::nullopt;
2495static std::optional<OptSpecifier>
2498 if (ActionOpt.first == ProgramAction)
2499 return OptSpecifier(ActionOpt.second);
2501 return std::nullopt;
2509#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2510 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
2511#include "clang/Driver/Options.inc"
2512#undef FRONTEND_OPTION_WITH_MARSHALLING
2514 std::optional<OptSpecifier> ProgramActionOpt =
2518 std::function<void()> GenerateProgramAction = [&]() {
2522 if (!ProgramActionOpt) {
2525 "Frontend action without option.");
2526 GenerateProgramAction = [&]() {
2533 GenerateProgramAction = [&]() {
2541 llvm_unreachable(
"Default AST dump format.");
2548 GenerateArg(Args, OPT_ast_dump_all_EQ, Format, SA);
2561 GenerateProgramAction = [&]() {
2566 GenerateProgramAction();
2568 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2570 const char *Spelling =
2571 SA(Opt.getPrefix() + Opt.getName() + PluginArgs.first);
2572 for (
const auto &PluginArg : PluginArgs.second)
2577 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2578 GenerateArg(Args, OPT_ftest_module_file_extension_EQ, TestExt->str(), SA);
2584 for (
const auto &Plugin : Opts.
Plugins)
2590 GenerateArg(Args, OPT_fmodule_file, ModuleFile, SA);
2597 GenerateArg(Args, OPT_aux_target_feature, Feature, SA);
2603 StringRef HeaderUnit =
"";
2608 HeaderUnit =
"-user";
2611 HeaderUnit =
"-system";
2614 HeaderUnit =
"-header-unit";
2617 StringRef Header = IsHeader ?
"-header" :
"";
2640 Lang =
"objective-c";
2643 Lang =
"objective-c++";
2646 Lang =
"renderscript";
2649 Lang =
"assembler-with-cpp";
2653 "Generating -x argument for unknown language (not precompiled).");
2665 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed, SA);
2669 for (
const auto &Input : Opts.
Inputs)
2670 Args.push_back(SA(Input.getFile()));
2679#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2680 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2681#include "clang/Driver/Options.inc"
2682#undef FRONTEND_OPTION_WITH_MARSHALLING
2685 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2686 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2688 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2691 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2692 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2695 .Default(std::numeric_limits<unsigned>::max());
2697 if (Val != std::numeric_limits<unsigned>::max())
2700 Diags.
Report(diag::err_drv_invalid_value)
2701 << A->getAsString(Args) << A->getValue();
2711 Args.hasArg(OPT_interface_stub_version_EQ)
2712 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2714 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2715 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2716 ArgStr ==
"experimental-tapi-elf-v1") {
2717 std::string ErrorMessage =
2718 "Invalid interface stub format: " + ArgStr.str() +
2720 Diags.
Report(diag::err_drv_invalid_value)
2721 <<
"Must specify a valid interface stub format type, ie: "
2722 "-interface-stub-version=ifs-v1"
2725 }
else if (!ArgStr.startswith(
"ifs-")) {
2726 std::string ErrorMessage =
2727 "Invalid interface stub format: " + ArgStr.str() +
".";
2728 Diags.
Report(diag::err_drv_invalid_value)
2729 <<
"Must specify a valid interface stub format type, ie: "
2730 "-interface-stub-version=ifs-v1"
2739 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2740 Opts.
Plugins.emplace_back(A->getValue(0));
2744 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2745 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2747 for (
const std::string &Arg :
2748 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2749 std::string BlockName;
2750 unsigned MajorVersion;
2751 unsigned MinorVersion;
2753 std::string UserInfo;
2755 MinorVersion, Hashed, UserInfo)) {
2756 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2763 std::make_shared<TestModuleFileExtension>(
2764 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2767 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2771 Diags.
Report(diag::err_drv_invalid_value)
2772 << A->getAsString(Args) << A->getValue();
2775 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2776 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2777 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2779 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2780 StringRef Val = A->getValue();
2781 if (!Val.contains(
'='))
2786 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2789 if (Args.hasArg(OPT_aux_target_cpu))
2790 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
2791 if (Args.hasArg(OPT_aux_target_feature))
2796 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2797 <<
"ARC migration" <<
"ObjC migration";
2801 if (
const Arg *A = Args.getLastArg(OPT_x)) {
2802 StringRef XValue = A->getValue();
2807 bool Preprocessed = XValue.consume_back(
"-cpp-output");
2808 bool ModuleMap = XValue.consume_back(
"-module-map");
2811 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
2817 if (IsHeader || Preprocessed) {
2818 if (XValue.consume_back(
"-header-unit"))
2820 else if (XValue.consume_back(
"-system"))
2822 else if (XValue.consume_back(
"-user"))
2828 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
2832 DashX = llvm::StringSwitch<InputKind>(XValue)
2849 DashX = llvm::StringSwitch<InputKind>(XValue)
2857 DashX = llvm::StringSwitch<InputKind>(XValue)
2860 .Cases(
"ast",
"pcm",
"precompiled-header",
2866 Diags.
Report(diag::err_drv_invalid_value)
2867 << A->getAsString(Args) << A->getValue();
2874 IsHeaderFile =
true;
2875 }
else if (IsHeaderFile)
2882 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
2885 Inputs.push_back(
"-");
2889 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
2891 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
2895 StringRef(Inputs[i]).rsplit(
'.').second);
2904 bool IsSystem =
false;
2913 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
2923 std::string ClangExecutable =
2924 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
2932#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
2933 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
2934#include "clang/Driver/Options.inc"
2935#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
2947 GenerateArg(Args, OPT_fprebuilt_module_path, Path, SA);
2950 GenerateArg(Args, OPT_fmodules_ignore_macro, Macro.val(), SA);
2954 std::optional<bool> IsFramework,
2955 std::optional<bool> IgnoreSysRoot) {
2956 return llvm::is_contained(Groups, Entry.
Group) &&
2957 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
2958 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
2966 std::nullopt,
true);
2968 OptSpecifier Opt = [It, Matches]() {
2977 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
2993 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3000 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3006 GenerateArg(Args, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3011 GenerateArg(Args, OPT_iframeworkwithsysroot, It->Path, SA);
3019 GenerateArg(Args, OPT_objc_isystem, It->Path, SA);
3021 GenerateArg(Args, OPT_objcxx_isystem, It->Path, SA);
3031 ? OPT_internal_isystem
3032 : OPT_internal_externc_isystem;
3036 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3040 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3041 : OPT_no_system_header_prefix;
3051 const std::string &WorkingDir) {
3056#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3057 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3058#include "clang/Driver/Options.inc"
3059#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3061 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3062 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3066 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3067 if (WorkingDir.empty())
3068 llvm::sys::fs::make_absolute(
P);
3070 llvm::sys::fs::make_absolute(WorkingDir,
P);
3072 llvm::sys::path::remove_dots(
P);
3076 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3077 StringRef Val = A->getValue();
3078 if (Val.contains(
'=')) {
3079 auto Split = Val.split(
'=');
3081 {std::string(Split.first), std::string(Split.second)});
3084 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3087 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3088 StringRef MacroDef = A->getValue();
3090 llvm::CachedHashString(MacroDef.split(
'=').first));
3094 bool IsIndexHeaderMap =
false;
3095 bool IsSysrootSpecified =
3096 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3097 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3098 if (A->getOption().matches(OPT_index_header_map)) {
3100 IsIndexHeaderMap =
true;
3107 bool IsFramework = A->getOption().matches(OPT_F);
3108 std::string Path = A->getValue();
3110 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3112 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3113 llvm::StringRef(A->getValue()).substr(1));
3114 Path = std::string(Buffer.str());
3117 Opts.
AddPath(Path, Group, IsFramework,
3119 IsIndexHeaderMap =
false;
3123 StringRef Prefix =
"";
3124 for (
const auto *A :
3125 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3126 if (A->getOption().matches(OPT_iprefix))
3127 Prefix = A->getValue();
3128 else if (A->getOption().matches(OPT_iwithprefix))
3134 for (
const auto *A : Args.filtered(OPT_idirafter))
3136 for (
const auto *A : Args.filtered(OPT_iquote))
3138 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
3140 !A->getOption().matches(OPT_iwithsysroot));
3141 for (
const auto *A : Args.filtered(OPT_iframework))
3143 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3148 for (
const auto *A : Args.filtered(OPT_c_isystem))
3150 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3152 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3154 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3158 for (
const auto *A :
3159 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3161 if (A->getOption().matches(OPT_internal_externc_isystem))
3163 Opts.
AddPath(A->getValue(), Group,
false,
true);
3167 for (
const auto *A :
3168 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3170 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3172 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3184 llvm_unreachable(
"should not parse language flags for this input");
3220 llvm_unreachable(
"unexpected input language");
3229 return "Objective-C";
3233 return "Objective-C++";
3237 return "C++ for OpenCL";
3241 return "RenderScript";
3256 llvm_unreachable(
"unknown input language");
3259void CompilerInvocation::GenerateLangArgs(
const LangOptions &Opts,
3265 if (Opts.ObjCAutoRefCount)
3267 if (Opts.PICLevel != 0)
3268 GenerateArg(Args, OPT_pic_level, Twine(Opts.PICLevel), SA);
3272 GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
3277 OptSpecifier StdOpt;
3279 case LangStandard::lang_opencl10:
3280 case LangStandard::lang_opencl11:
3281 case LangStandard::lang_opencl12:
3282 case LangStandard::lang_opencl20:
3283 case LangStandard::lang_opencl30:
3284 case LangStandard::lang_openclcpp10:
3285 case LangStandard::lang_openclcpp2021:
3286 StdOpt = OPT_cl_std_EQ;
3289 StdOpt = OPT_std_EQ;
3296 if (Opts.IncludeDefaultHeader)
3297 GenerateArg(Args, OPT_finclude_default_header, SA);
3298 if (Opts.DeclareOpenCLBuiltins)
3299 GenerateArg(Args, OPT_fdeclare_opencl_builtins, SA);
3303#define LANG_OPTION_WITH_MARSHALLING(...) \
3304 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
3305#include "clang/Driver/Options.inc"
3306#undef LANG_OPTION_WITH_MARSHALLING
3317 else if (Opts.ObjCAutoRefCount == 1)
3320 if (Opts.ObjCWeakRuntime)
3321 GenerateArg(Args, OPT_fobjc_runtime_has_weak, SA);
3326 if (Opts.ObjCSubscriptingLegacyRuntime)
3327 GenerateArg(Args, OPT_fobjc_subscripting_legacy_runtime, SA);
3330 if (Opts.GNUCVersion != 0) {
3331 unsigned Major = Opts.GNUCVersion / 100 / 100;
3332 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3333 unsigned Patch = Opts.GNUCVersion % 100;
3335 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch), SA);
3338 if (Opts.IgnoreXCOFFVisibility)
3339 GenerateArg(Args, OPT_mignore_xcoff_visibility, SA);
3348 if (Opts.MSCompatibilityVersion != 0) {
3349 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3350 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3351 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3353 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor), SA);
3356 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS()) {
3357 if (!Opts.Trigraphs)
3364 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3367 if (Opts.ConvergentFunctions &&
3368 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice))
3371 if (Opts.NoBuiltin && !Opts.Freestanding)
3374 if (!Opts.NoBuiltin)
3378 if (Opts.LongDoubleSize == 128)
3380 else if (Opts.LongDoubleSize == 64)
3382 else if (Opts.LongDoubleSize == 80)
3389 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3392 if (Opts.OpenMP != 50)
3393 GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3395 if (!Opts.OpenMPUseTLS)
3398 if (Opts.OpenMPIsDevice)
3401 if (Opts.OpenMPIRBuilder)
3402 GenerateArg(Args, OPT_fopenmp_enable_irbuilder, SA);
3405 if (Opts.OpenMPSimd) {
3408 if (Opts.OpenMP != 50)
3409 GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3412 if (Opts.OpenMPThreadSubscription)
3413 GenerateArg(Args, OPT_fopenmp_assume_threads_oversubscription, SA);
3415 if (Opts.OpenMPTeamSubscription)
3416 GenerateArg(Args, OPT_fopenmp_assume_teams_oversubscription, SA);
3418 if (Opts.OpenMPTargetDebug != 0)
3420 Twine(Opts.OpenMPTargetDebug), SA);
3422 if (Opts.OpenMPCUDANumSMs != 0)
3423 GenerateArg(Args, OPT_fopenmp_cuda_number_of_sm_EQ,
3424 Twine(Opts.OpenMPCUDANumSMs), SA);
3426 if (Opts.OpenMPCUDABlocksPerSM != 0)
3427 GenerateArg(Args, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3428 Twine(Opts.OpenMPCUDABlocksPerSM), SA);
3430 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3431 GenerateArg(Args, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3432 Twine(Opts.OpenMPCUDAReductionBufNum), SA);
3435 std::string Targets;
3436 llvm::raw_string_ostream
OS(Targets);
3439 [&
OS](
const llvm::Triple &T) { OS << T.str(); },
",");
3446 if (Opts.OpenMPCUDAMode)
3459 GenerateArg(Args, OPT_ffp_contract,
"fast-honor-pragmas", SA);
3462 GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
3466 GenerateArg(Args, OPT_fsanitize_ignorelist_EQ, F, SA);
3469 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"3.8", SA);
3471 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"4.0", SA);
3473 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"6.0", SA);
3475 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"7.0", SA);
3477 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"9.0", SA);
3479 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"11.0", SA);
3481 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"12.0", SA);
3483 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"14.0", SA);
3485 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"15.0", SA);
3487 if (Opts.getSignReturnAddressScope() ==
3489 GenerateArg(Args, OPT_msign_return_address_EQ,
"all", SA);
3490 else if (Opts.getSignReturnAddressScope() ==
3492 GenerateArg(Args, OPT_msign_return_address_EQ,
"non-leaf", SA);
3494 if (Opts.getSignReturnAddressKey() ==
3496 GenerateArg(Args, OPT_msign_return_address_key_EQ,
"b_key", SA);
3502 if (Opts.RelativeCXXABIVTables)
3503 GenerateArg(Args, OPT_fexperimental_relative_cxx_abi_vtables, SA);
3505 GenerateArg(Args, OPT_fno_experimental_relative_cxx_abi_vtables, SA);
3513 GenerateArg(Args, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second, SA);
3519bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3521 std::vector<std::string> &Includes,
3530 if (Args.hasArg(OPT_fobjc_arc))
3531 Opts.ObjCAutoRefCount = 1;
3535 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3547 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3550 Diags.
Report(diag::err_drv_invalid_value)
3551 << A->getAsString(Args) << A->getValue();
3553 for (
unsigned KindValue = 0;
3559 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3560 Diag <<
Std.getName() <<
Std.getDescription();
3561 unsigned NumAliases = 0;
3562#define LANGSTANDARD(id, name, lang, desc, features)
3563#define LANGSTANDARD_ALIAS(id, alias) \
3564 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3565#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3566#include "clang/Basic/LangStandards.def"
3568#define LANGSTANDARD(id, name, lang, desc, features)
3569#define LANGSTANDARD_ALIAS(id, alias) \
3570 if (KindValue == LangStandard::lang_##id) Diag << alias;
3571#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3572#include "clang/Basic/LangStandards.def"
3580 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3588 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3590 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3591 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3592 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3593 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3594 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3595 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3596 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3597 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
3598 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
3599 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
3603 Diags.
Report(diag::err_drv_invalid_value)
3604 << A->getAsString(Args) << A->getValue();
3607 LangStd = OpenCLLangStd;
3611 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3612 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3620#define LANG_OPTION_WITH_MARSHALLING(...) \
3621 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3622#include "clang/Driver/Options.inc"
3623#undef LANG_OPTION_WITH_MARSHALLING
3625 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3626 StringRef Name = A->getValue();
3627 if (Name ==
"full" || Name ==
"branch") {
3628 Opts.CFProtectionBranch = 1;
3632 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3633 !Args.hasArg(OPT_sycl_std_EQ)) {
3643 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3644 StringRef value =
arg->getValue();
3646 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3649 if (Args.hasArg(OPT_fobjc_gc_only))
3651 else if (Args.hasArg(OPT_fobjc_gc))
3653 else if (Args.hasArg(OPT_fobjc_arc)) {
3654 Opts.ObjCAutoRefCount = 1;
3656 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3663 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3664 Opts.ObjCWeakRuntime = 1;
3670 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3671 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3672 assert(!Opts.ObjCWeak);
3674 Diags.
Report(diag::err_objc_weak_with_gc);
3675 }
else if (!Opts.ObjCWeakRuntime) {
3676 Diags.
Report(diag::err_objc_weak_unsupported);
3680 }
else if (Opts.ObjCAutoRefCount) {
3681 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3684 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3685 Opts.ObjCSubscriptingLegacyRuntime =
3689 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
3692 VersionTuple GNUCVer;
3693 bool Invalid = GNUCVer.tryParse(A->getValue());
3694 unsigned Major = GNUCVer.getMajor();
3695 unsigned Minor = GNUCVer.getMinor().value_or(0);
3696 unsigned Patch = GNUCVer.getSubminor().value_or(0);
3697 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
3698 Diags.
Report(diag::err_drv_invalid_value)
3699 << A->getAsString(Args) << A->getValue();
3701 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
3704 if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
3705 Opts.IgnoreXCOFFVisibility = 1;
3707 if (Args.hasArg(OPT_ftrapv)) {
3711 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
3713 else if (Args.hasArg(OPT_fwrapv))
3716 Opts.MSCompatibilityVersion = 0;
3717 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
3719 if (VT.tryParse(A->getValue()))
3720 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3722 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
3723 VT.getMinor().value_or(0) * 100000 +
3724 VT.getSubminor().value_or(0);
3732 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS();
3734 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
3736 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
3737 && Opts.OpenCLVersion == 200);
3739 Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
3740 Opts.SYCLIsDevice ||
3741 Args.hasArg(OPT_fconvergent_functions);
3743 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
3744 if (!Opts.NoBuiltin)
3746 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
3747 if (A->getOption().matches(options::OPT_mlong_double_64))
3748 Opts.LongDoubleSize = 64;
3749 else if (A->getOption().matches(options::OPT_mlong_double_80))
3750 Opts.LongDoubleSize = 80;
3751 else if (A->getOption().matches(options::OPT_mlong_double_128))
3752 Opts.LongDoubleSize = 128;
3754 Opts.LongDoubleSize = 0;
3756 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
3762 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3764 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3765 << A->getSpelling() <<
"-fdefault-calling-conv";
3767 if (T.getArch() != llvm::Triple::x86)
3768 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3769 << A->getSpelling() << T.getTriple();
3776 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 50 : 0;
3778 bool IsSimdSpecified =
3779 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
3781 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
3783 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
3784 Opts.OpenMPIsDevice =
3785 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
3786 Opts.OpenMPIRBuilder =
3787 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
3788 bool IsTargetSpecified =
3789 Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
3791 Opts.ConvergentFunctions = Opts.ConvergentFunctions || Opts.OpenMPIsDevice;
3793 if (Opts.OpenMP || Opts.OpenMPSimd) {
3795 Args, OPT_fopenmp_version_EQ,
3796 (IsSimdSpecified || IsTargetSpecified) ? 50 : Opts.OpenMP, Diags))
3797 Opts.OpenMP = Version;
3800 if (!Opts.OpenMPIsDevice) {
3801 switch (T.getArch()) {
3805 case llvm::Triple::nvptx:
3806 case llvm::Triple::nvptx64:
3807 Diags.
Report(diag::err_drv_omp_host_target_not_supported) << T.str();
3815 if ((Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN())) ||
3816 Opts.OpenCLCPlusPlus) {
3818 Opts.Exceptions = 0;
3819 Opts.CXXExceptions = 0;
3821 if (Opts.OpenMPIsDevice && T.isNVPTX()) {
3822 Opts.OpenMPCUDANumSMs =
3824 Opts.OpenMPCUDANumSMs, Diags);
3825 Opts.OpenMPCUDABlocksPerSM =
3827 Opts.OpenMPCUDABlocksPerSM, Diags);
3829 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3830 Opts.OpenMPCUDAReductionBufNum, Diags);
3835 if (Opts.OpenMPIsDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
3836 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
3838 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
3839 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
3840 Opts.OpenMPTargetDebug = 1;
3843 if (Opts.OpenMPIsDevice) {
3844 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
3845 Opts.OpenMPTeamSubscription =
true;
3846 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
3847 Opts.OpenMPThreadSubscription =
true;
3851 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
3852 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
3853 auto getArchPtrSize = [](
const llvm::Triple &T) {
3854 if (T.isArch16Bit())
3856 if (T.isArch32Bit())
3858 assert(T.isArch64Bit() &&
"Expected 64-bit architecture");
3862 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
3863 llvm::Triple TT(A->getValue(i));
3865 if (TT.getArch() == llvm::Triple::UnknownArch ||
3866 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
3867 TT.getArch() == llvm::Triple::nvptx ||
3868 TT.getArch() == llvm::Triple::nvptx64 ||
3869 TT.getArch() == llvm::Triple::amdgcn ||
3870 TT.getArch() == llvm::Triple::x86 ||
3871 TT.getArch() == llvm::Triple::x86_64))
3872 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
3873 else if (getArchPtrSize(T) != getArchPtrSize(TT))
3874 Diags.
Report(diag::err_drv_incompatible_omp_arch)
3875 << A->getValue(i) << T.str();
3883 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
3886 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
3891 Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) &&
3892 Args.hasArg(options::OPT_fopenmp_cuda_mode);
3897 Opts.Optimize = Opt != 0;
3898 Opts.OptimizeSize = OptSize != 0;
3903 Opts.NoInlineDefine = !Opts.Optimize;
3904 if (Arg *InlineArg = Args.getLastArg(
3905 options::OPT_finline_functions, options::OPT_finline_hint_functions,
3906 options::OPT_fno_inline_functions, options::OPT_fno_inline))
3907 if (InlineArg->getOption().matches(options::OPT_fno_inline))
3908 Opts.NoInlineDefine =
true;
3910 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
3911 StringRef Val = A->getValue();
3914 else if (Val ==
"on")
3916 else if (Val ==
"off")
3918 else if (Val ==
"fast-honor-pragmas")
3921 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
3927 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
3928 std::vector<std::string> systemIgnorelists =
3929 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
3931 systemIgnorelists.begin(),
3932 systemIgnorelists.end());
3934 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
3937 StringRef Ver = A->getValue();
3938 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
3939 unsigned Major, Minor = 0;
3943 if (!VerParts.first.startswith(
"0") &&
3944 !VerParts.first.getAsInteger(10, Major) &&
3945 3 <= Major && Major <= CLANG_VERSION_MAJOR &&
3946 (Major == 3 ? VerParts.second.size() == 1 &&
3947 !VerParts.second.getAsInteger(10, Minor)
3948 : VerParts.first.size() == Ver.size() ||
3949 VerParts.second ==
"0")) {
3951 if (Major == 3 && Minor <= 8)
3953 else if (Major <= 4)
3955 else if (Major <= 6)
3957 else if (Major <= 7)
3959 else if (Major <= 9)
3961 else if (Major <= 11)
3963 else if (Major <= 12)
3965 else if (Major <= 14)
3967 else if (Major <= 15)
3969 }
else if (Ver !=
"latest") {
3970 Diags.
Report(diag::err_drv_invalid_value)
3971 << A->getAsString(Args) << A->getValue();
3975 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
3976 StringRef SignScope = A->getValue();
3978 if (SignScope.equals_insensitive(
"none"))
3979 Opts.setSignReturnAddressScope(
3981 else if (SignScope.equals_insensitive(
"all"))
3982 Opts.setSignReturnAddressScope(
3984 else if (SignScope.equals_insensitive(
"non-leaf"))
3985 Opts.setSignReturnAddressScope(
3988 Diags.
Report(diag::err_drv_invalid_value)
3989 << A->getAsString(Args) << SignScope;
3991 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
3992 StringRef SignKey = A->getValue();
3993 if (!SignScope.empty() && !SignKey.empty()) {
3994 if (SignKey.equals_insensitive(
"a_key"))
3995 Opts.setSignReturnAddressKey(
3997 else if (SignKey.equals_insensitive(
"b_key"))
3998 Opts.setSignReturnAddressKey(
4001 Diags.
Report(diag::err_drv_invalid_value)
4002 << A->getAsString(Args) << SignKey;
4008 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4015 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI << T.str();
4021 Opts.RelativeCXXABIVTables =
4022 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4023 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4026 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4027 auto Split = StringRef(A).split(
'=');
4029 {std::string(
Split.first), std::string(
Split.second)});
4033 !Args.getLastArg(OPT_fno_file_reproducible) &&
4034 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4035 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4036 Args.getLastArg(OPT_ffile_reproducible));
4039 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4041 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4042 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4045 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4046 std::ifstream SeedFile(A->getValue(0));
4048 if (!SeedFile.is_open())
4049 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4055 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4060 bool SupportedTarget = T.getArch() == llvm::Triple::dxil &&
4061 T.getOS() == llvm::Triple::ShaderModel;
4062 if (!SupportedTarget)
4063 Diags.
Report(diag::err_drv_hlsl_unsupported_target) << T.str();
4111 llvm_unreachable(
"invalid frontend action");
4122#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4123 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
4124#include "clang/Driver/Options.inc"
4125#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4128 GenerateArg(Args, OPT_pch_through_hdrstop_use, SA);
4131 GenerateArg(Args, OPT_error_on_deserialized_pch_decl, D, SA);
4139 for (
const auto &M : Opts.
Macros) {
4142 if (M.first ==
"__CET__=1" && !M.second &&
4143 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4145 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4146 !CodeGenOpts.CFProtectionBranch)
4148 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4149 CodeGenOpts.CFProtectionBranch)
4152 GenerateArg(Args, M.second ? OPT_U : OPT_D, M.first, SA);
4155 for (
const auto &I : Opts.
Includes) {
4158 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4159 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4164 if (LangOpts.HLSL && I ==
"hlsl.h")
4174 GenerateArg(Args, OPT_remap_file, RF.first +
";" + RF.second, SA);
4191#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4192 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4193#include "clang/Driver/Options.inc"
4194#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4196 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4197 Args.hasArg(OPT_pch_through_hdrstop_use);
4199 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4202 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4203 StringRef
Value(A->getValue());
4204 size_t Comma =
Value.find(
',');
4206 unsigned EndOfLine = 0;
4208 if (Comma == StringRef::npos ||
4209 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4210 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4211 Diags.
Report(diag::err_drv_preamble_format);
4219 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4220 StringRef Name = A->getValue();
4221 if (Name ==
"branch")
4223 else if (Name ==
"return")
4225 else if (Name ==
"full")
4230 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4231 if (A->getOption().matches(OPT_D))
4238 for (
const auto *A : Args.filtered(OPT_include))
4239 Opts.
Includes.emplace_back(A->getValue());
4241 for (
const auto *A : Args.filtered(OPT_chain_include))
4244 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4245 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4247 if (Split.second.empty()) {
4248 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4255 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4256 StringRef Epoch = A->getValue();
4260 const uint64_t MaxTimestamp =
4261 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4263 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4264 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4265 << Epoch << MaxTimestamp;
4285#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4286 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
4287#include "clang/Driver/Options.inc"
4288#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4306#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4307 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4308#include "clang/Driver/Options.inc"
4309#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4312 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4322#define TARGET_OPTION_WITH_MARSHALLING(...) \
4323 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, __VA_ARGS__)
4324#include "clang/Driver/Options.inc"
4325#undef TARGET_OPTION_WITH_MARSHALLING
4331 GenerateArg(Args, OPT_darwin_target_variant_sdk_version_EQ,
4341#define TARGET_OPTION_WITH_MARSHALLING(...) \
4342 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4343#include "clang/Driver/Options.inc"
4344#undef TARGET_OPTION_WITH_MARSHALLING
4346 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4347 llvm::VersionTuple Version;
4348 if (Version.tryParse(A->getValue()))
4349 Diags.
Report(diag::err_drv_invalid_value)
4350 << A->getAsString(Args) << A->getValue();
4355 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4356 llvm::VersionTuple Version;
4357 if (Version.tryParse(A->getValue()))
4358 Diags.
Report(diag::err_drv_invalid_value)
4359 << A->getAsString(Args) << A->getValue();
4367bool CompilerInvocation::CreateFromArgsImpl(
4375 unsigned MissingArgIndex, MissingArgCount;
4376 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4377 MissingArgCount, IncludedFlagsBitmask);
4381 if (MissingArgCount)
4382 Diags.
Report(diag::err_drv_missing_argument)
4383 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4386 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4387 auto ArgString = A->getAsString(Args);
4388 std::string Nearest;
4389 if (Opts.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
4390 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4392 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4393 << ArgString << Nearest;
4439 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4440 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4441 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4442 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4455 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4461 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4475 Diags, llvm::vfs::getRealFileSystem());
4489 const char *Argv0) {
4495 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4499 Args.push_back(
"-cc1");
4502 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4507 llvm::HashBuilder<llvm::MD5, llvm::support::endianness::native> HBuilder;
4520#define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
4521#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4522 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
4523#define BENIGN_LANGOPT(Name, Bits, Default, Description)
4524#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4525#include "clang/Basic/LangOptions.def"
4527 HBuilder.addRange(
LangOpts->ModuleFeatures);
4529 HBuilder.add(
LangOpts->ObjCRuntime);
4530 HBuilder.addRange(
LangOpts->CommentOpts.BlockCommandNames);
4535 HBuilder.addRange(
TargetOpts->FeaturesAsWritten);
4547 StringRef MacroDef = Macro.first;
4549 llvm::CachedHashString(MacroDef.split(
'=').first)))
4553 HBuilder.add(Macro);
4568#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
4569#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4570 HBuilder.add(diagOpts.get##Name());
4571#include "clang/Basic/DiagnosticOptions.def"
4581 ext->hashExtension(HBuilder);
4592 if (!SanHash.
empty())
4593 HBuilder.add(SanHash.
Mask);
4595 llvm::MD5::MD5Result
Result;
4596 HBuilder.getHasher().final(
Result);
4598 return toString(llvm::APInt(64, Hash), 36,
false);
4624 llvm::BumpPtrAllocator Alloc;
4625 llvm::StringSaver Strings(Alloc);
4626 auto SA = [&Strings](
const Twine &Arg) {
return Strings.save(Arg).data(); };
4633 return std::vector<std::string>{Args.begin(), Args.end()};
4657 llvm::vfs::getRealFileSystem());
4665 Diags, std::move(BaseFS));
4671 if (VFSOverlayFiles.empty())
4676 for (
const auto &
File : VFSOverlayFiles) {
4677 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
4680 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
4685 std::move(Buffer.get()),
nullptr,
File,
4688 Diags.
Report(diag::err_invalid_vfs_overlay) <<
File;
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static CompilationDatabasePluginRegistry::Add< FixedCompilationDatabasePlugin > X("fixed-compilation-database", "Reads plain-text flags file")
static void getAllNoBuiltinFuncValues(ArgList &Args, std::vector< std::string > &Funcs)
static T extractMaskValue(T KeyPath)
static void GenerateFileSystemArgs(const FileSystemOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA)
static std::optional< IntTy > normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &Diags)
static T mergeMaskValue(T KeyPath, U Value)
static std::optional< std::string > normalizeString(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, OptSpecifier OtherOpt)
static SmallVector< StringRef, 4 > serializeSanitizerKinds(SanitizerSet S)
static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, ArgList &Args, DiagnosticsEngine &D, XRayInstrSet &S)
static unsigned getOptimizationLevelSize(ArgList &Args)
static std::optional< SimpleEnumValue > findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value)
static void GenerateFrontendArgs(const FrontendOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA, bool IsHeader)
static void GeneratePreprocessorArgs(PreprocessorOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA, const LangOptions &LangOpts, const FrontendOptions &FrontendOpts, const CodeGenOptions &CodeGenOpts)
static bool ParseTargetArgs(TargetOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static auto makeFlagToValueNormalizer(T Value)
static CodeGenOptions::OptRemark ParseOptimizationRemark(DiagnosticsEngine &Diags, ArgList &Args, OptSpecifier OptEQ, StringRef Name)
Parse a remark command line argument.
static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static constexpr bool is_uint64_t_convertible()
static std::optional< SimpleEnumValue > findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name)
static std::optional< OptSpecifier > getProgramActionOpt(frontend::ActionKind ProgramAction)
Maps frontend action to command line option.
static bool parseDiagnosticLevelMask(StringRef FlagName, const std::vector< std::string > &Levels, DiagnosticsEngine &Diags, DiagnosticLevelMask &M)
static std::optional< bool > normalizeSimpleFlag(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, OptSpecifier GroupWithValue, std::vector< std::string > &Diagnostics)
static void GenerateOptimizationRemark(SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA, OptSpecifier OptEQ, StringRef Name, const CodeGenOptions::OptRemark &Remark)
Generate a remark argument. This is an inverse of ParseOptimizationRemark.
static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, DiagnosticsEngine *Diags)
static bool ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, const FrontendOptions &FrontendOpts)
static std::optional< unsigned > normalizeSimpleEnum(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static StringRef GetInputKindName(InputKind IK)
Get language name for given input kind.
static void denormalizeSimpleEnumImpl(SmallVectorImpl< const char * > &Args, const char *Spelling, CompilerInvocation::StringAllocator SA, Option::OptionClass OptClass, unsigned TableIndex, unsigned Value)
static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, StringRef &OptionField, StringRef Name, StringRef DefaultVal)
static void denormalizeString(SmallVectorImpl< const char * > &Args, const char *Spelling, CompilerInvocation::StringAllocator SA, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static std::optional< std::string > normalizeTriple(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
llvm::function_ref< bool(CompilerInvocation &, ArrayRef< const char * >, DiagnosticsEngine &, const char *)> ParseFn
llvm::function_ref< void(CompilerInvocation &, SmallVectorImpl< const char * > &, CompilerInvocation::StringAllocator)> GenerateFn
static void GeneratePreprocessorOutputArgs(const PreprocessorOutputOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA, frontend::ActionKind Action)
static const auto & getFrontendActionTable()
Return a table that associates command line option specifiers with the frontend action.
static std::optional< frontend::ActionKind > getFrontendAction(OptSpecifier &Opt)
Maps command line option to frontend action.
static bool checkVerifyPrefixes(const std::vector< std::string > &VerifyPrefixes, DiagnosticsEngine &Diags)
static std::optional< bool > normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, const ArgList &Args, DiagnosticsEngine &)
static bool IsInputCompatibleWithStandard(InputKind IK, const LangStandard &S)
Check if input file kind and language standard are compatible.
static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName, llvm::vfs::FileSystem &FS, DiagnosticsEngine &Diags)
static void denormalizeSimpleFlag(SmallVectorImpl< const char * > &Args, const char *Spelling, CompilerInvocation::StringAllocator, Option::OptionClass, unsigned,...)
The tblgen-erated code passes in a fifth parameter of an arbitrary type, but denormalizeSimpleFlags n...
static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, const std::string &WorkingDir)
static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, bool &IsHeaderFile)
static auto makeBooleanOptionDenormalizer(bool Value)
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action)
static std::string serializeXRayInstrumentationBundle(const XRayInstrSet &S)
static bool ParseMigratorArgs(MigratorOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor)
static T mergeForwardValue(T KeyPath, U Value)
static void GenerateHeaderSearchArgs(HeaderSearchOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA)
static void GenerateArg(SmallVectorImpl< const char * > &Args, llvm::opt::OptSpecifier OptSpecifier, CompilerInvocation::StringAllocator SA)
static bool ParseDependencyOutputArgs(DependencyOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, bool ShowLineMarkers)
static Expected< std::optional< uint32_t > > parseToleranceOption(StringRef Arg)
static std::optional< std::vector< std::string > > normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &)
static bool ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action)
static void GenerateMigratorArgs(const MigratorOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA)
static bool RoundTrip(ParseFn Parse, GenerateFn Generate, CompilerInvocation &RealInvocation, CompilerInvocation &DummyInvocation, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0, bool CheckAgainstOriginalInvocation=false, bool ForceRoundTrip=false)
May perform round-trip of command line arguments.
static T extractForwardValue(T KeyPath)
static void GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA)
static void denormalizeStringImpl(SmallVectorImpl< const char * > &Args, const char *Spelling, CompilerInvocation::StringAllocator SA, Option::OptionClass OptClass, unsigned, const Twine &Value)
static unsigned getOptimizationLevel(ArgList &Args, InputKind IK, DiagnosticsEngine &Diags)
static void GenerateAnalyzerArgs(AnalyzerOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA)
static void GenerateTargetArgs(const TargetOptions &Opts, SmallVectorImpl< const char * > &Args, CompilerInvocation::StringAllocator SA)
static void denormalizeSimpleEnum(SmallVectorImpl< const char * > &Args, const char *Spelling, CompilerInvocation::StringAllocator SA, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static bool parseTestModuleFileExtensionArg(StringRef Arg, std::string &BlockName, unsigned &MajorVersion, unsigned &MinorVersion, bool &Hashed, std::string &UserInfo)
Parse the argument to the -ftest-module-file-extension command-line argument.
static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config, StringRef OptionName, StringRef DefaultVal)
static bool FixupInvocation(CompilerInvocation &Invocation, DiagnosticsEngine &Diags, const ArgList &Args, InputKind IK)
static void parseSanitizerKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S)
static void denormalizeStringVector(SmallVectorImpl< const char * > &Args, const char *Spelling, CompilerInvocation::StringAllocator SA, Option::OptionClass OptClass, unsigned TableIndex, const std::vector< std::string > &Values)
Defines the clang::FileSystemOptions interface.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Defines types useful for describing an Objective-C runtime.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::SanitizerKind enum.
Defines the clang::SourceLocation class and associated facilities.
Defines the clang::TargetOptions class.
Defines version macros and version-related utility functions for Clang.
Defines the clang::Visibility enumeration and various utility functions.
Defines the clang::XRayInstrKind enum.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Stores options for the analyzer from the command line.
static std::vector< StringRef > getRegisteredPackages(bool IncludeExperimental=false)
Retrieves the list of packages generated from Checkers.td.
std::vector< std::pair< std::string, bool > > CheckersAndPackages
Pairs of checker/package name and enable/disable.
std::vector< std::string > SilencedCheckersAndPackages
Vector of checker/package names which will not emit warnings.
AnalysisDiagClients AnalysisDiagOpt
AnalysisConstraints AnalysisConstraintsOpt
ConfigTable Config
A key-value table of use-specified configuration values.
bool isUnknownAnalyzerConfig(StringRef Name) const
unsigned ShouldEmitErrorsOnInvalidConfigValue
AnalysisPurgeMode AnalysisPurgeOpt
static std::vector< StringRef > getRegisteredCheckers(bool IncludeExperimental=false)
Retrieves the list of checkers generated from Checkers.td.
llvm::StringMap< std::string > ConfigTable
std::string FullCompilerInvocation
Store full compiler invocation for reproducible instructions in the generated report.
AnalysisInliningMode InliningMode
The mode of function selection used during inlining.
static bool isBuiltinFunc(llvm::StringRef Name)
Returns true if this is a libc/libm function without the '__builtin_' prefix.
Implements C++ ABI-specific semantic analysis functions.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::string OptRecordFile
The name of the file to which the backend should save YAML optimization records.
std::string BinutilsVersion
std::vector< BitcodeFileToLink > LinkBitcodeFiles
The files specified here are linked in to the module before optimizations.
std::optional< uint64_t > DiagnosticsHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
char CoverageVersion[4]
The version string to put into coverage files.
llvm::DenormalMode FPDenormalMode
The floating-point denormal mode to use.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
std::string MemoryProfileOutput
Name of the profile file to use as output for with -fmemory-profile.
std::string CodeModel
The code model to use (-mcmodel).
std::map< std::string, std::string > DebugPrefixMap
std::optional< uint32_t > DiagnosticsMisExpectTolerance
The maximum percentage profiling weights can deviate from the expected values in order to be included...
std::string StackUsageOutput
Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.
std::string OptRecordPasses
The regex that filters the passes that should be saved to the optimization records.
std::string SaveTempsFilePrefix
Prefix to use for -save-temps output.
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
bool hasSanitizeCoverage() const
llvm::DenormalMode FP32DenormalMode
The floating-point denormal mode to use, for float.
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
bool hasReducedDebugInfo() const
Check if type and variable info should be emitted.
OptRemark OptimizationRemark
Selected optimizations for which we should enable optimization remarks.
std::string ThinLTOIndexFile
Name of the function summary index file to use for ThinLTO function importing.
const char * Argv0
Executable and command-line used to create a given CompilerInvocation.
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
OptRemark OptimizationRemarkAnalysis
Selected optimizations for which we should enable optimization analyses.
std::vector< std::string > CommandLineArgs
std::string OptRecordFormat
The format used for serializing remarks (default: YAML)
std::map< std::string, std::string > CoveragePrefixMap
std::string DIBugsReportFilePath
The file to use for dumping bug report by Debugify for original debug info.
OptRemark OptimizationRemarkMissed
Selected optimizations for which we should enable missed optimization remarks.
The base class of CompilerInvocation with reference semantics.
PreprocessorOptions & getPreprocessorOpts()
AnalyzerOptionsRef AnalyzerOpts
Options controlling the static analyzer.
TargetOptions & getTargetOpts()
~CompilerInvocationRefBase()
CompilerInvocationRefBase & operator=(CompilerInvocationRefBase X)
DiagnosticOptions & getDiagnosticOpts() const
IntrusiveRefCntPtr< DiagnosticOptions > DiagnosticOpts
Options controlling the diagnostic engine.
AnalyzerOptionsRef getAnalyzerOpts() const
std::shared_ptr< PreprocessorOptions > PreprocessorOpts
Options controlling the preprocessor (aside from #include handling).
LangOptions * getLangOpts()
std::shared_ptr< LangOptions > LangOpts
Options controlling the language variant.
HeaderSearchOptions & getHeaderSearchOpts()
std::shared_ptr< TargetOptions > TargetOpts
Options controlling the target.
std::shared_ptr< HeaderSearchOptions > HeaderSearchOpts
Options controlling the #include directive.
CompilerInvocationRefBase()
FileSystemOptions FileSystemOpts
Options controlling file system operations.
CodeGenOptions & getCodeGenOpts()
FileSystemOptions & getFileSystemOpts()
DependencyOutputOptions & getDependencyOutputOpts()
MigratorOptions & getMigratorOpts()
CodeGenOptions CodeGenOpts
Options controlling IRgen and the backend.
FrontendOptions & getFrontendOpts()
PreprocessorOutputOptions PreprocessorOutputOpts
Options controlling preprocessed output.
PreprocessorOutputOptions & getPreprocessorOutputOpts()
FrontendOptions FrontendOpts
Options controlling the frontend itself.
MigratorOptions MigratorOpts
DependencyOutputOptions DependencyOutputOpts
Options controlling dependency output.
Helper class for holding the data necessary to invoke the compiler.
void clearImplicitModuleBuildOptions()
Disable implicit modules and canonicalize options that are only used by implicit modules.
static std::string GetResourcesPath(const char *Argv0, void *MainAddr)
Get the directory where the compiler headers reside, relative to the compiler binary (found by the pa...
static bool CreateFromArgs(CompilerInvocation &Res, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Create a compiler invocation from a list of input options.
static bool checkCC1RoundTrip(ArrayRef< const char * > Args, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Check that Args can be parsed and re-serialized without change, emiting diagnostics for any differenc...
void resetNonModularOptions()
Reset all of the options that are not considered when building a module.
void generateCC1CommandLine(llvm::SmallVectorImpl< const char * > &Args, StringAllocator SA) const
Generate cc1-compatible command line arguments from this instance.
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
std::vector< std::string > getCC1CommandLine() const
Generate cc1-compatible command line arguments from this instance, wrapping the result as a std::vect...
llvm::function_ref< const char *(const llvm::Twine &)> StringAllocator
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
ShowIncludesDestination ShowIncludesDest
Destination of cl.exe style /showIncludes info.
HeaderIncludeFormatKind HeaderIncludeFormat
The format of header information.
std::string OutputFile
The file to write dependency output to.
HeaderIncludeFilteringKind HeaderIncludeFiltering
Determine whether header information should be filtered.
std::vector< std::string > Targets
A list of names to use as the targets in the dependency file; this list must contain at least one ent...
std::vector< std::pair< std::string, ExtraDepKind > > ExtraDeps
A list of extra dependencies (filename and kind) to be used for every target.
unsigned IncludeSystemHeaders
Include system header dependencies.
Used for handling and querying diagnostic IDs.
Options for controlling the compiler diagnostics engine.