30 #include "clang/Config/config.h"
49 #include "llvm/ADT/APInt.h"
50 #include "llvm/ADT/ArrayRef.h"
51 #include "llvm/ADT/CachedHashString.h"
52 #include "llvm/ADT/DenseSet.h"
53 #include "llvm/ADT/FloatingPointMode.h"
54 #include "llvm/ADT/Hashing.h"
55 #include "llvm/ADT/None.h"
56 #include "llvm/ADT/Optional.h"
57 #include "llvm/ADT/STLExtras.h"
58 #include "llvm/ADT/SmallString.h"
59 #include "llvm/ADT/SmallVector.h"
60 #include "llvm/ADT/StringRef.h"
61 #include "llvm/ADT/StringSwitch.h"
62 #include "llvm/ADT/Triple.h"
63 #include "llvm/ADT/Twine.h"
64 #include "llvm/Config/llvm-config.h"
65 #include "llvm/IR/DebugInfoMetadata.h"
66 #include "llvm/Linker/Linker.h"
67 #include "llvm/MC/MCTargetOptions.h"
68 #include "llvm/Option/Arg.h"
69 #include "llvm/Option/ArgList.h"
70 #include "llvm/Option/OptSpecifier.h"
71 #include "llvm/Option/OptTable.h"
72 #include "llvm/Option/Option.h"
73 #include "llvm/ProfileData/InstrProfReader.h"
74 #include "llvm/Remarks/HotnessThresholdParser.h"
75 #include "llvm/Support/CodeGen.h"
76 #include "llvm/Support/Compiler.h"
77 #include "llvm/Support/Error.h"
78 #include "llvm/Support/ErrorHandling.h"
79 #include "llvm/Support/ErrorOr.h"
80 #include "llvm/Support/FileSystem.h"
81 #include "llvm/Support/HashBuilder.h"
82 #include "llvm/Support/Host.h"
83 #include "llvm/Support/MathExtras.h"
84 #include "llvm/Support/MemoryBuffer.h"
85 #include "llvm/Support/Path.h"
86 #include "llvm/Support/Process.h"
87 #include "llvm/Support/Regex.h"
88 #include "llvm/Support/VersionTuple.h"
89 #include "llvm/Support/VirtualFileSystem.h"
90 #include "llvm/Support/raw_ostream.h"
91 #include "llvm/Target/TargetOptions.h"
101 #include <type_traits>
105 using namespace clang;
106 using namespace driver;
107 using namespace options;
118 if (Arg.getAsInteger(10, Val))
119 return llvm::createStringError(llvm::inconvertibleErrorCode(),
120 "Not an integer: %s", Arg.data());
167 #define SIMPLE_ENUM_VALUE_TABLE
168 #include "clang/Driver/Options.inc"
169 #undef SIMPLE_ENUM_VALUE_TABLE
175 if (Args.hasArg(Opt))
183 if (Args.hasArg(Opt))
193 const char *Spelling,
195 Option::OptionClass,
unsigned, ...) {
196 Args.push_back(Spelling);
200 return !std::is_same<T, uint64_t>::value &&
201 llvm::is_integral_or_enum<T>::value;
204 template <
typename T,
205 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
207 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
209 if (Args.hasArg(Opt))
215 template <
typename T,
216 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
222 OptSpecifier OtherOpt) {
223 return [
Value, OtherValue, OtherOpt](OptSpecifier Opt,
unsigned,
226 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
227 return A->getOption().matches(Opt) ?
Value : OtherValue;
237 if (KeyPath ==
Value)
238 Args.push_back(Spelling);
243 const char *Spelling,
245 Option::OptionClass OptClass,
unsigned,
246 const Twine &
Value) {
248 case Option::SeparateClass:
249 case Option::JoinedOrSeparateClass:
250 case Option::JoinedAndSeparateClass:
251 Args.push_back(Spelling);
252 Args.push_back(SA(
Value));
254 case Option::JoinedClass:
255 case Option::CommaJoinedClass:
256 Args.push_back(SA(Twine(Spelling) +
Value));
259 llvm_unreachable(
"Cannot denormalize an option with option class "
260 "incompatible with string denormalization.");
264 template <
typename T>
268 Option::OptionClass OptClass,
unsigned TableIndex, T
Value) {
274 for (
int I = 0, E = Table.Size; I != E; ++I)
275 if (Name == Table.Table[I].Name)
276 return Table.Table[I];
283 for (
int I = 0, E = Table.Size; I != E; ++I)
284 if (
Value == Table.Table[I].Value)
285 return Table.Table[I];
294 assert(TableIndex < SimpleEnumValueTablesSize);
295 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
297 auto *Arg = Args.getLastArg(Opt);
301 StringRef ArgValue = Arg->getValue();
303 return MaybeEnumVal->Value;
305 Diags.
Report(diag::err_drv_invalid_value)
306 << Arg->getAsString(Args) << ArgValue;
311 const char *Spelling,
313 Option::OptionClass OptClass,
314 unsigned TableIndex,
unsigned Value) {
315 assert(TableIndex < SimpleEnumValueTablesSize);
316 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
321 llvm_unreachable(
"The simple enum value was not correctly defined in "
322 "the tablegen option description");
326 template <
typename T>
328 const char *Spelling,
330 Option::OptionClass OptClass,
331 unsigned TableIndex, T
Value) {
333 static_cast<unsigned>(
Value));
339 auto *Arg = Args.getLastArg(Opt);
345 template <
typename IntTy>
349 auto *Arg = Args.getLastArg(Opt);
353 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354 Diags.
Report(diag::err_drv_invalid_int_value)
355 << Arg->getAsString(Args) << Arg->getValue();
364 return Args.getAllArgValues(Opt);
368 const char *Spelling,
370 Option::OptionClass OptClass,
372 const std::vector<std::string> &Values) {
374 case Option::CommaJoinedClass: {
376 if (!Values.empty()) {
377 CommaJoinedValue.append(Values.front());
379 CommaJoinedValue.append(
",");
380 CommaJoinedValue.append(
Value);
384 TableIndex, CommaJoinedValue);
387 case Option::JoinedClass:
388 case Option::SeparateClass:
389 case Option::JoinedOrSeparateClass:
394 llvm_unreachable(
"Cannot denormalize an option with option class "
395 "incompatible with string vector denormalization.");
402 auto *Arg = Args.getLastArg(Opt);
408 template <
typename T,
typename U>
410 return static_cast<T
>(
Value);
414 return KeyPath |
Value;
421 template <
typename T,
typename U, U Value>
426 #define PARSE_OPTION_WITH_MARSHALLING( \
427 ARGS, DIAGS, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
428 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX) \
429 if ((FLAGS)&options::CC1Option) { \
430 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
432 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
434 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
436 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
441 #define GENERATE_OPTION_WITH_MARSHALLING( \
442 ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, \
443 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, \
445 if ((FLAGS)&options::CC1Option) { \
446 [&](const auto &Extracted) { \
449 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
450 : (DEFAULT_VALUE)))) \
451 DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class, \
452 TABLE_INDEX, Extracted); \
453 }(EXTRACTOR(KEYPATH)); \
467 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
468 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
469 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
470 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
473 CodeGenOpts.ClearASTBeforeBackend =
false;
475 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
476 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
479 llvm::Triple T(TargetOpts.
Triple);
480 llvm::Triple::ArchType Arch = T.getArch();
484 if (LangOpts.getExceptionHandling() !=
486 T.isWindowsMSVCEnvironment())
487 Diags.
Report(diag::err_fe_invalid_exception_model)
488 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str();
490 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
491 Diags.
Report(diag::warn_c_kext);
493 if (Args.hasArg(OPT_fconcepts_ts))
494 Diags.
Report(diag::warn_fe_concepts_ts_flag);
496 if (LangOpts.NewAlignOverride &&
497 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
498 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
499 Diags.
Report(diag::err_fe_invalid_alignment)
500 << A->getAsString(Args) << A->getValue();
501 LangOpts.NewAlignOverride = 0;
505 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
506 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
509 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
510 Diags.
Report(diag::err_drv_argument_not_allowed_with)
513 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
514 Diags.
Report(diag::warn_ignored_hip_only_option)
515 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
517 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
518 Diags.
Report(diag::warn_ignored_hip_only_option)
519 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
528 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
529 if (LangOpts.ApproxFunc)
530 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
531 if (LangOpts.AllowFPReassoc)
532 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
533 if (LangOpts.AllowRecip)
534 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
540 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
542 Diags.
Report(diag::warn_option_invalid_ocl_version)
544 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
546 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
547 auto DefaultCC = LangOpts.getDefaultCallingConv();
551 Arch != llvm::Triple::x86;
556 Diags.
Report(diag::err_drv_argument_not_allowed_with)
557 << A->getSpelling() << T.getTriple();
572 !Args.hasArg(OPT_cl_opt_disable))
573 DefaultOpt = llvm::CodeGenOpt::Default;
575 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
576 if (A->getOption().matches(options::OPT_O0))
579 if (A->getOption().matches(options::OPT_Ofast))
580 return llvm::CodeGenOpt::Aggressive;
582 assert(A->getOption().matches(options::OPT_O));
584 StringRef S(A->getValue());
585 if (S ==
"s" || S ==
"z")
586 return llvm::CodeGenOpt::Default;
589 return llvm::CodeGenOpt::Less;
598 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
599 if (A->getOption().matches(options::OPT_O)) {
600 switch (A->getValue()[0]) {
614 llvm::opt::OptSpecifier OptSpecifier,
618 Option::OptionClass::FlagClass, 0);
622 llvm::opt::OptSpecifier OptSpecifier,
627 Opt.getKind(), 0,
Value);
653 bool DoRoundTripDefault =
true;
655 bool DoRoundTripDefault =
false;
658 bool DoRoundTrip = DoRoundTripDefault;
659 for (
const auto *Arg : CommandLineArgs) {
660 if (Arg == StringRef(
"-round-trip-args"))
662 if (Arg == StringRef(
"-no-round-trip-args"))
669 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
674 llvm::raw_string_ostream OS(Buffer);
675 for (
const char *Arg : Args) {
676 llvm::sys::printArg(OS, Arg,
true);
689 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
696 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
702 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
703 Diags.
Report(diag::note_cc1_round_trip_original)
704 << SerializeArgs(CommandLineArgs);
709 llvm::BumpPtrAllocator Alloc;
710 llvm::StringSaver StringPool(Alloc);
711 auto SA = [&StringPool](
const Twine &Arg) {
712 return StringPool.save(Arg).data();
718 SmallVector<const char *> GeneratedArgs1;
719 Generate(DummyInvocation, GeneratedArgs1, SA);
725 bool Success2 = Parse(RealInvocation, GeneratedArgs1, Diags, Argv0);
730 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
731 Diags.
Report(diag::note_cc1_round_trip_generated)
732 << 1 << SerializeArgs(GeneratedArgs1);
738 SmallVector<const char *> GeneratedArgs2;
739 Generate(RealInvocation, GeneratedArgs2, SA);
744 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
745 [](
const char *AElem,
const char *BElem) {
746 return StringRef(AElem) == StringRef(BElem);
753 if (!
Equal(GeneratedArgs1, GeneratedArgs2)) {
754 Diags.
Report(diag::err_cc1_round_trip_mismatch);
755 Diags.
Report(diag::note_cc1_round_trip_generated)
756 << 1 << SerializeArgs(GeneratedArgs1);
757 Diags.
Report(diag::note_cc1_round_trip_generated)
758 << 2 << SerializeArgs(GeneratedArgs2);
762 Diags.
Report(diag::remark_cc1_round_trip_generated)
763 << 1 << SerializeArgs(GeneratedArgs1);
764 Diags.
Report(diag::remark_cc1_round_trip_generated)
765 << 2 << SerializeArgs(GeneratedArgs2);
771 OptSpecifier GroupWithValue,
772 std::vector<std::string> &Diagnostics) {
773 for (
auto *A : Args.filtered(
Group)) {
774 if (A->getOption().getKind() == Option::FlagClass) {
777 Diagnostics.push_back(
778 std::string(A->getOption().getName().drop_front(1)));
779 }
else if (A->getOption().matches(GroupWithValue)) {
782 Diagnostics.push_back(
783 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
786 Diagnostics.push_back(A->getValue());
797 std::vector<std::string> &Funcs) {
798 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
800 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
808 #define ANALYZER_OPTION_WITH_MARSHALLING( \
809 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
810 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
811 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
812 MERGER, EXTRACTOR, TABLE_INDEX) \
813 GENERATE_OPTION_WITH_MARSHALLING( \
814 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
815 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
816 #include "clang/Driver/Options.inc"
817 #undef ANALYZER_OPTION_WITH_MARSHALLING
821 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
823 GenerateArg(Args, OPT_analyzer_constraints, CMDFLAG, SA); \
825 #include "clang/StaticAnalyzer/Core/Analyses.def"
827 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
833 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
835 GenerateArg(Args, OPT_analyzer_output, CMDFLAG, SA); \
837 #include "clang/StaticAnalyzer/Core/Analyses.def"
839 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
845 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
847 GenerateArg(Args, OPT_analyzer_purge, CMDFLAG, SA); \
849 #include "clang/StaticAnalyzer/Core/Analyses.def"
851 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
857 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
859 GenerateArg(Args, OPT_analyzer_inlining_mode, CMDFLAG, SA); \
861 #include "clang/StaticAnalyzer/Core/Analyses.def"
863 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
869 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
876 for (
const auto &C : Opts.
Config) {
879 auto Entry = ConfigOpts.
Config.find(C.getKey());
880 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() == C.getValue())
883 GenerateArg(Args, OPT_analyzer_config, C.getKey() +
"=" + C.getValue(), SA);
895 #define ANALYZER_OPTION_WITH_MARSHALLING( \
896 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
897 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
898 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
899 MERGER, EXTRACTOR, TABLE_INDEX) \
900 PARSE_OPTION_WITH_MARSHALLING( \
901 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
902 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
903 #include "clang/Driver/Options.inc"
904 #undef ANALYZER_OPTION_WITH_MARSHALLING
906 if (Args.hasArg(OPT_analyzer_store))
907 Diags.
Report(diag::warn_analyzer_deprecated_option) <<
"-analyzer-store"
909 if (Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks))
910 Diags.
Report(diag::warn_analyzer_deprecated_option)
911 <<
"-analyzer-opt-analyze-nested-blocks"
914 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
915 StringRef Name = A->getValue();
917 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
918 .Case(CMDFLAG, NAME##Model)
919 #include "clang/StaticAnalyzer/Core/Analyses.def"
922 Diags.
Report(diag::err_drv_invalid_value)
923 << A->getAsString(Args) << Name;
926 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
927 Diags.
Report(diag::err_analyzer_not_built_with_z3);
929 #endif // LLVM_WITH_Z3
934 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
935 StringRef Name = A->getValue();
937 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
938 .Case(CMDFLAG, PD_##NAME)
939 #include "clang/StaticAnalyzer/Core/Analyses.def"
942 Diags.
Report(diag::err_drv_invalid_value)
943 << A->getAsString(Args) << Name;
949 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
950 StringRef Name = A->getValue();
952 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
954 #include "clang/StaticAnalyzer/Core/Analyses.def"
957 Diags.
Report(diag::err_drv_invalid_value)
958 << A->getAsString(Args) << Name;
964 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
965 StringRef Name = A->getValue();
967 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
969 #include "clang/StaticAnalyzer/Core/Analyses.def"
972 Diags.
Report(diag::err_drv_invalid_value)
973 << A->getAsString(Args) << Name;
981 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
983 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
986 StringRef CheckerAndPackageList = A->getValue();
988 CheckerAndPackageList.split(CheckersAndPackages,
",");
989 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
995 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
999 StringRef configList = A->getValue();
1000 SmallVector<StringRef, 4> configVals;
1001 configList.split(configVals,
",");
1002 for (
const auto &configVal : configVals) {
1004 std::tie(key, val) = configVal.split(
"=");
1007 diag::err_analyzer_config_no_value) << configVal;
1010 if (val.contains(
'=')) {
1012 diag::err_analyzer_config_multiple_values)
1021 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1036 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1039 os << Args.getArgString(i);
1047 StringRef OptionName, StringRef DefaultVal) {
1048 return Config.insert({OptionName,
std::string(DefaultVal)}).first->second;
1053 StringRef &OptionField, StringRef Name,
1054 StringRef DefaultVal) {
1063 bool &OptionField, StringRef Name,
bool DefaultVal) {
1064 auto PossiblyInvalidVal = llvm::StringSwitch<Optional<bool>>(
1067 .Case(
"false",
false)
1070 if (!PossiblyInvalidVal) {
1072 Diags->
Report(diag::err_analyzer_config_invalid_input)
1073 << Name <<
"a boolean";
1075 OptionField = DefaultVal;
1077 OptionField = *PossiblyInvalidVal;
1082 unsigned &OptionField, StringRef Name,
1083 unsigned DefaultVal) {
1085 OptionField = DefaultVal;
1086 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1087 .getAsInteger(0, OptionField);
1088 if (Diags && HasFailed)
1089 Diags->
Report(diag::err_analyzer_config_invalid_input)
1090 << Name <<
"an unsigned";
1098 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1099 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1100 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1101 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1103 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1104 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1106 #define ANALYZER_OPTION(...)
1107 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1108 SHALLOW_VAL, DEEP_VAL) \
1109 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1110 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1111 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1118 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1119 std::vector<StringRef> Checkers =
1121 std::vector<StringRef> Packages =
1125 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1127 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1129 bool IsChecker = CheckerOrPackage.contains(
'.');
1130 bool IsValidName = IsChecker
1131 ? llvm::is_contained(Checkers, CheckerOrPackage)
1132 : llvm::is_contained(Packages, CheckerOrPackage);
1135 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1136 << CheckerOrPackage;
1146 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1147 Diags->
Report(diag::err_analyzer_config_invalid_input)
1148 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1150 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1151 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1154 if (!AnOpts.ModelPath.empty() &&
1155 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1156 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1164 OptSpecifier OptEQ, StringRef Name,
1166 if (Remark.hasValidPattern()) {
1171 GenerateArg(Args, OPT_R_Joined, StringRef(
"no-") + Name, SA);
1180 OptSpecifier OptEQ, StringRef Name) {
1183 auto InitializeResultPattern = [&Diags, &Args, &Result](
const Arg *A,
1184 StringRef Pattern) {
1185 Result.Pattern = Pattern.str();
1188 Result.Regex = std::make_shared<llvm::Regex>(Result.Pattern);
1189 if (!Result.Regex->isValid(RegexError)) {
1190 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1191 << RegexError << A->getAsString(Args);
1198 for (Arg *A : Args) {
1199 if (A->getOption().matches(OPT_R_Joined)) {
1200 StringRef
Value = A->getValue();
1204 else if (
Value ==
"everything")
1206 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1208 else if (
Value ==
"no-everything")
1215 Result.Pattern =
"";
1216 Result.Regex =
nullptr;
1218 InitializeResultPattern(A,
".*");
1220 }
else if (A->getOption().matches(OptEQ)) {
1222 if (!InitializeResultPattern(A, A->getValue()))
1231 const std::vector<std::string> &Levels,
1234 bool Success =
true;
1235 for (
const auto &
Level : Levels) {
1237 llvm::StringSwitch<DiagnosticLevelMask>(
Level)
1245 Diags.
Report(diag::err_drv_invalid_value) << FlagName <<
Level;
1253 const std::vector<std::string> &Sanitizers,
1255 for (
const auto &Sanitizer : Sanitizers) {
1258 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1265 SmallVector<StringRef, 4> Values;
1274 llvm::SplitString(Bundle, BundleParts,
",");
1275 for (
const auto &B : BundleParts) {
1279 D.
Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1293 llvm::raw_string_ostream OS(Buffer);
1294 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1300 const Twine &ProfileName) {
1303 if (
auto E = ReaderOrErr.takeError()) {
1304 llvm::consumeError(std::move(E));
1308 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1309 std::move(ReaderOrErr.get());
1310 if (PGOReader->isIRLevelProfile()) {
1311 if (PGOReader->hasCSIRLevelProfile())
1319 void CompilerInvocation::GenerateCodeGenArgs(
1321 StringAllocator SA,
const llvm::Triple &T,
const std::string &OutputFile,
1325 if (Opts.OptimizationLevel == 0)
1328 GenerateArg(Args, OPT_O, Twine(Opts.OptimizationLevel), SA);
1330 #define CODEGEN_OPTION_WITH_MARSHALLING( \
1331 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
1332 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
1333 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
1334 MERGER, EXTRACTOR, TABLE_INDEX) \
1335 GENERATE_OPTION_WITH_MARSHALLING( \
1336 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
1337 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
1338 #include "clang/Driver/Options.inc"
1339 #undef CODEGEN_OPTION_WITH_MARSHALLING
1341 if (Opts.OptimizationLevel > 0) {
1345 GenerateArg(Args, OPT_finline_hint_functions, SA);
1350 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1351 GenerateArg(Args, OPT_fdirect_access_external_data, SA);
1352 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1353 GenerateArg(Args, OPT_fno_direct_access_external_data, SA);
1356 switch (Opts.DebugInfo) {
1358 DebugInfoVal =
"line-tables-only";
1361 DebugInfoVal =
"line-directives-only";
1364 DebugInfoVal =
"limited";
1367 DebugInfoVal =
"standalone";
1370 DebugInfoVal =
"unused-types";
1373 DebugInfoVal =
None;
1376 DebugInfoVal =
None;
1380 GenerateArg(Args, OPT_debug_info_kind_EQ, *DebugInfoVal, SA);
1384 Prefix.first +
"=" + Prefix.second, SA);
1388 Prefix.first +
"=" + Prefix.second, SA);
1390 if (Opts.NewStructPathTBAA)
1393 if (Opts.OptimizeSize == 1)
1395 else if (Opts.OptimizeSize == 2)
1403 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1405 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1411 if (Opts.DebugNameTable ==
1412 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1414 else if (Opts.DebugNameTable ==
1415 static_cast<unsigned>(
1416 llvm::DICompileUnit::DebugNameTableKind::Default))
1419 auto TNK = Opts.getDebugSimpleTemplateNames();
1422 GenerateArg(Args, OPT_gsimple_template_names_EQ,
"simple", SA);
1424 GenerateArg(Args, OPT_gsimple_template_names_EQ,
"mangled", SA);
1429 if (Opts.TimePasses) {
1430 if (Opts.TimePassesPerRun)
1431 GenerateArg(Args, OPT_ftime_report_EQ,
"per-pass-run", SA);
1436 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1439 if (Opts.PrepareForThinLTO)
1448 StringRef MemProfileBasename(
"memprof.profraw");
1471 if (!InstrBundle.empty())
1472 GenerateArg(Args, OPT_fxray_instrumentation_bundle, InstrBundle, SA);
1475 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1476 GenerateArg(Args, OPT_fcf_protection_EQ,
"full", SA);
1477 else if (Opts.CFProtectionReturn)
1478 GenerateArg(Args, OPT_fcf_protection_EQ,
"return", SA);
1479 else if (Opts.CFProtectionBranch)
1480 GenerateArg(Args, OPT_fcf_protection_EQ,
"branch", SA);
1486 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1487 F.PropagateAttrs && F.Internalize;
1489 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1496 if (Opts.ExplicitEmulatedTLS) {
1498 Args, Opts.EmulatedTLS ? OPT_femulated_tls : OPT_fno_emulated_tls, SA);
1511 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1515 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1519 if (Opts.EnableAIXExtendedAltivecABI)
1537 GenerateArg(Args, OPT_fdiagnostics_hotness_threshold_EQ,
1543 GenerateArg(Args, OPT_fdiagnostics_misexpect_tolerance_EQ,
1547 GenerateArg(Args, OPT_fsanitize_recover_EQ, Sanitizer, SA);
1550 GenerateArg(Args, OPT_fsanitize_trap_EQ, Sanitizer, SA);
1552 if (!Opts.EmitVersionIdentMetadata)
1555 switch (Opts.FiniteLoops) {
1558 case CodeGenOptions::FiniteLoopsKind::Always:
1561 case CodeGenOptions::FiniteLoopsKind::Never:
1567 bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1570 const llvm::Triple &T,
1577 unsigned MaxOptLevel = 3;
1578 if (OptimizationLevel > MaxOptLevel) {
1581 Diags.
Report(diag::warn_drv_optimization_value)
1582 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1583 OptimizationLevel = MaxOptLevel;
1585 Opts.OptimizationLevel = OptimizationLevel;
1594 #define CODEGEN_OPTION_WITH_MARSHALLING( \
1595 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
1596 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
1597 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
1598 MERGER, EXTRACTOR, TABLE_INDEX) \
1599 PARSE_OPTION_WITH_MARSHALLING( \
1600 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
1601 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
1602 #include "clang/Driver/Options.inc"
1603 #undef CODEGEN_OPTION_WITH_MARSHALLING
1607 if (Opts.OptimizationLevel == 0) {
1609 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1610 options::OPT_finline_hint_functions,
1611 options::OPT_fno_inline_functions,
1612 options::OPT_fno_inline)) {
1615 if (A->getOption().matches(options::OPT_finline_functions))
1617 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1627 Opts.DirectAccessExternalData =
1628 Args.hasArg(OPT_fdirect_access_external_data) ||
1629 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1632 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1634 llvm::StringSwitch<unsigned>(A->getValue())
1642 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1648 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1649 auto Split = StringRef(Arg).split(
'=');
1654 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1655 auto Split = StringRef(Arg).split(
'=');
1660 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1661 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1662 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1663 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1666 llvm::is_contained(DebugEntryValueArchs, T.getArch()))
1667 Opts.EmitCallSiteInfo =
true;
1670 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1675 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1676 Args.hasArg(OPT_new_struct_path_tbaa);
1678 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1679 if (Opts.SimplifyLibCalls)
1682 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1683 (Opts.OptimizationLevel > 1));
1685 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1687 Opts.DebugNameTable =
static_cast<unsigned>(
1688 Args.hasArg(OPT_ggnu_pubnames)
1689 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1690 : Args.hasArg(OPT_gpubnames)
1691 ? llvm::DICompileUnit::DebugNameTableKind::Default
1693 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1694 StringRef
Value = A->getValue();
1696 Diags.
Report(diag::err_drv_unsupported_option_argument)
1697 << A->getOption().getName() << A->getValue();
1698 Opts.setDebugSimpleTemplateNames(
1699 StringRef(A->getValue()) ==
"simple"
1707 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1708 Opts.TimePasses =
true;
1711 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1712 StringRef Val = A->getValue();
1713 if (Val ==
"per-pass")
1714 Opts.TimePassesPerRun =
false;
1715 else if (Val ==
"per-pass-run")
1716 Opts.TimePassesPerRun =
true;
1718 Diags.
Report(diag::err_drv_invalid_value)
1719 << A->getAsString(Args) << A->getValue();
1723 Opts.PrepareForLTO =
false;
1724 Opts.PrepareForThinLTO =
false;
1725 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1726 Opts.PrepareForLTO =
true;
1727 StringRef S = A->getValue();
1729 Opts.PrepareForThinLTO =
true;
1730 else if (S !=
"full")
1731 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1733 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1735 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1736 << A->getAsString(Args) <<
"-x ir";
1738 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1740 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1742 llvm::StringSwitch<std::string>(A->getValue())
1743 .Case(
"obj", OutputFile)
1744 .Default(llvm::sys::path::filename(OutputFile).str());
1747 const char *MemProfileBasename =
"memprof.profraw";
1748 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1750 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1751 llvm::sys::path::append(Path, MemProfileBasename);
1753 }
else if (Args.hasArg(OPT_fmemory_profile))
1757 if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
1758 if (Args.hasArg(OPT_coverage_version_EQ)) {
1759 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1760 if (CoverageVersion.size() != 4) {
1761 Diags.
Report(diag::err_drv_invalid_value)
1762 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1772 for (
const auto &A : Args) {
1774 if (A->getOption().getID() == options::OPT_o ||
1775 A->getOption().getID() == options::OPT_INPUT ||
1776 A->getOption().getID() == options::OPT_x ||
1777 A->getOption().getID() == options::OPT_fembed_bitcode ||
1778 A->getOption().matches(options::OPT_W_Group))
1781 A->render(Args, ASL);
1782 for (
const auto &
arg : ASL) {
1783 StringRef ArgStr(
arg);
1784 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1790 auto XRayInstrBundles =
1791 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1792 if (XRayInstrBundles.empty())
1795 for (
const auto &A : XRayInstrBundles)
1799 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1800 StringRef Name = A->getValue();
1801 if (Name ==
"full") {
1802 Opts.CFProtectionReturn = 1;
1803 Opts.CFProtectionBranch = 1;
1804 }
else if (Name ==
"return")
1805 Opts.CFProtectionReturn = 1;
1806 else if (Name ==
"branch")
1807 Opts.CFProtectionBranch = 1;
1808 else if (Name !=
"none")
1809 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1812 if (Opts.PrepareForLTO && Args.hasArg(OPT_mibt_seal))
1816 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1819 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1820 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1829 if (Args.getLastArg(OPT_femulated_tls) ||
1830 Args.getLastArg(OPT_fno_emulated_tls)) {
1831 Opts.ExplicitEmulatedTLS =
true;
1834 if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
1836 StringRef Name = A->getValue();
1837 if (Name !=
"global-dynamic")
1838 Diags.
Report(diag::err_aix_unsupported_tls_model) << Name;
1842 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1843 StringRef Val = A->getValue();
1847 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1850 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
1851 StringRef Val = A->getValue();
1854 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1860 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
1861 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
1865 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
1866 << A->getSpelling() << T.str();
1868 const Option &O = A->getOption();
1869 if (O.matches(OPT_fpcc_struct_return) ||
1870 O.matches(OPT_maix_struct_return)) {
1873 assert(O.matches(OPT_freg_struct_return) ||
1874 O.matches(OPT_msvr4_struct_return));
1880 Args.getLastArg(OPT_mabi_EQ_vec_default, OPT_mabi_EQ_vec_extabi)) {
1882 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
1883 << A->getSpelling() << T.str();
1885 const Option &O = A->getOption();
1886 Opts.EnableAIXExtendedAltivecABI = O.matches(OPT_mabi_EQ_vec_extabi);
1889 bool NeedLocTracking =
false;
1892 NeedLocTracking =
true;
1894 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
1896 NeedLocTracking =
true;
1899 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
1901 NeedLocTracking =
true;
1911 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
1918 bool UsingProfile = UsingSampleProfile ||
1921 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
1924 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1925 <<
"-fdiagnostics-show-hotness";
1929 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
1931 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
1934 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
1935 <<
"-fdiagnostics-hotness-threshold=";
1941 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1942 <<
"-fdiagnostics-hotness-threshold=";
1947 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
1951 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
1952 <<
"-fdiagnostics-misexpect-tolerance=";
1958 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
1959 <<
"-fdiagnostics-misexpect-tolerance=";
1966 if (UsingSampleProfile)
1967 NeedLocTracking =
true;
1970 NeedLocTracking =
true;
1980 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
1983 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
1986 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
1988 if (Args.hasArg(options::OPT_ffinite_loops))
1989 Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Always;
1990 else if (Args.hasArg(options::OPT_fno_finite_loops))
1991 Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Never;
1993 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
1994 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
1995 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
1996 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2006 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING( \
2007 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2008 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2009 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2010 MERGER, EXTRACTOR, TABLE_INDEX) \
2011 GENERATE_OPTION_WITH_MARSHALLING( \
2012 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2013 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2014 #include "clang/Driver/Options.inc"
2015 #undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2020 for (
const auto &Dep : Opts.
ExtraDeps) {
2021 switch (Dep.second) {
2034 GenerateArg(Args, OPT_fdepfile_entry, Dep.first, SA);
2043 bool ShowLineMarkers) {
2047 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING( \
2048 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2049 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2050 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2051 MERGER, EXTRACTOR, TABLE_INDEX) \
2052 PARSE_OPTION_WITH_MARSHALLING( \
2053 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2054 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2055 #include "clang/Driver/Options.inc"
2056 #undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2058 if (Args.hasArg(OPT_show_includes)) {
2073 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2074 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2075 StringRef Val = A->getValue();
2076 if (!Val.contains(
'='))
2080 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2081 StringRef Val = A->getValue();
2082 if (!Val.contains(
'='))
2089 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2093 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2097 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2098 StringRef Val = A->getValue();
2099 if (!Val.contains(
'='))
2115 } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2116 for (
auto *A : Args) {
2117 const Option &O = A->getOption();
2118 if (O.matches(options::OPT_fcolor_diagnostics)) {
2119 ShowColors = Colors_On;
2120 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2121 ShowColors = Colors_Off;
2122 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2123 StringRef
Value(A->getValue());
2124 if (
Value ==
"always")
2125 ShowColors = Colors_On;
2126 else if (
Value ==
"never")
2127 ShowColors = Colors_Off;
2128 else if (
Value ==
"auto")
2129 ShowColors = Colors_Auto;
2132 return ShowColors == Colors_On ||
2133 (ShowColors == Colors_Auto &&
2134 llvm::sys::Process::StandardErrHasColors());
2139 bool Success =
true;
2140 for (
const auto &Prefix : VerifyPrefixes) {
2143 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2146 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2148 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2149 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2160 #define FILE_SYSTEM_OPTION_WITH_MARSHALLING( \
2161 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2162 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2163 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2164 MERGER, EXTRACTOR, TABLE_INDEX) \
2165 GENERATE_OPTION_WITH_MARSHALLING( \
2166 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2167 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2168 #include "clang/Driver/Options.inc"
2169 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2178 #define FILE_SYSTEM_OPTION_WITH_MARSHALLING( \
2179 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2180 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2181 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2182 MERGER, EXTRACTOR, TABLE_INDEX) \
2183 PARSE_OPTION_WITH_MARSHALLING( \
2184 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2185 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2186 #include "clang/Driver/Options.inc"
2187 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2196 #define MIGRATOR_OPTION_WITH_MARSHALLING( \
2197 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2198 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2199 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2200 MERGER, EXTRACTOR, TABLE_INDEX) \
2201 GENERATE_OPTION_WITH_MARSHALLING( \
2202 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2203 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2204 #include "clang/Driver/Options.inc"
2205 #undef MIGRATOR_OPTION_WITH_MARSHALLING
2214 #define MIGRATOR_OPTION_WITH_MARSHALLING( \
2215 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2216 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2217 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2218 MERGER, EXTRACTOR, TABLE_INDEX) \
2219 PARSE_OPTION_WITH_MARSHALLING( \
2220 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2221 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2222 #include "clang/Driver/Options.inc"
2223 #undef MIGRATOR_OPTION_WITH_MARSHALLING
2228 void CompilerInvocation::GenerateDiagnosticArgs(
2230 StringAllocator SA,
bool DefaultDiagColor) {
2232 #define DIAG_OPTION_WITH_MARSHALLING( \
2233 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2234 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2235 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2236 MERGER, EXTRACTOR, TABLE_INDEX) \
2237 GENERATE_OPTION_WITH_MARSHALLING( \
2238 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2239 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2240 #include "clang/Driver/Options.inc"
2241 #undef DIAG_OPTION_WITH_MARSHALLING
2247 if (Opts.ShowColors)
2250 if (Opts.VerifyDiagnostics &&
2255 if (Prefix !=
"expected")
2262 GenerateArg(Args, OPT_verify_ignore_unexpected, SA);
2265 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"note", SA);
2267 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"remark", SA);
2269 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"warning", SA);
2271 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"error", SA);
2274 for (
const auto &Warning : Opts.
Warnings) {
2276 if (Warning ==
"undef-prefix")
2278 Args.push_back(SA(StringRef(
"-W") + Warning));
2281 for (
const auto &Remark : Opts.
Remarks) {
2284 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2285 "pass-analysis",
"no-pass-analysis",
2286 "pass-missed",
"no-pass-missed"};
2287 if (llvm::is_contained(IgnoredRemarks, Remark))
2290 Args.push_back(SA(StringRef(
"-R") + Remark));
2294 std::unique_ptr<DiagnosticOptions>
2296 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2297 unsigned MissingArgIndex, MissingArgCount;
2299 Argv.slice(1), MissingArgIndex, MissingArgCount);
2309 bool DefaultDiagColor) {
2314 Diags = &*IgnoringDiags;
2323 #define DIAG_OPTION_WITH_MARSHALLING( \
2324 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2325 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2326 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2327 MERGER, EXTRACTOR, TABLE_INDEX) \
2328 PARSE_OPTION_WITH_MARSHALLING( \
2329 Args, *Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2330 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2331 #include "clang/Driver/Options.inc"
2332 #undef DIAG_OPTION_WITH_MARSHALLING
2334 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2337 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2341 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2343 if (Args.hasArg(OPT_verify))
2348 Opts.VerifyDiagnostics =
false;
2353 "-verify-ignore-unexpected=",
2354 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2355 if (Args.hasArg(OPT_verify_ignore_unexpected))
2357 Opts.setVerifyIgnoreUnexpected(DiagMask);
2360 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2376 unsigned &MajorVersion,
2377 unsigned &MinorVersion,
2380 SmallVector<StringRef, 5> Args;
2381 Arg.split(Args,
':', 5);
2382 if (Args.size() < 5)
2386 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2387 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2388 if (Args[3].getAsInteger(2, Hashed))
return true;
2389 if (Args.size() > 4)
2399 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2446 OPT_print_dependency_directives_minimized_source},
2455 if (ActionOpt.second == Opt.getID())
2456 return ActionOpt.first;
2465 if (ActionOpt.first == ProgramAction)
2466 return OptSpecifier(ActionOpt.second);
2476 #define FRONTEND_OPTION_WITH_MARSHALLING( \
2477 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2478 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2479 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2480 MERGER, EXTRACTOR, TABLE_INDEX) \
2481 GENERATE_OPTION_WITH_MARSHALLING( \
2482 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2483 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2484 #include "clang/Driver/Options.inc"
2485 #undef FRONTEND_OPTION_WITH_MARSHALLING
2491 std::function<void()> GenerateProgramAction = [&]() {
2495 if (!ProgramActionOpt) {
2498 "Frontend action without option.");
2499 GenerateProgramAction = [&]() {
2506 GenerateProgramAction = [&]() {
2514 llvm_unreachable(
"Default AST dump format.");
2521 GenerateArg(Args, OPT_ast_dump_all_EQ, Format, SA);
2534 GenerateProgramAction = [&]() {
2539 GenerateProgramAction();
2541 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2543 const char *Spelling =
2544 SA(Opt.getPrefix() + Opt.getName() + PluginArgs.first);
2545 for (
const auto &PluginArg : PluginArgs.second)
2550 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2551 GenerateArg(Args, OPT_ftest_module_file_extension_EQ, TestExt->str(), SA);
2557 for (
const auto &Plugin : Opts.
Plugins)
2563 GenerateArg(Args, OPT_fmodule_file, ModuleFile, SA);
2570 GenerateArg(Args, OPT_aux_target_feature, Feature, SA);
2576 StringRef HeaderUnit =
"";
2581 HeaderUnit =
"-user";
2584 HeaderUnit =
"-system";
2587 HeaderUnit =
"-header-unit";
2590 StringRef Header = IsHeader ?
"-header" :
"";
2613 Lang =
"objective-c";
2616 Lang =
"objective-c++";
2619 Lang =
"renderscript";
2622 Lang =
"assembler-with-cpp";
2626 "Generating -x argument for unknown language (not precompiled).");
2638 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed, SA);
2642 for (
const auto &Input : Opts.
Inputs)
2643 Args.push_back(SA(Input.getFile()));
2652 #define FRONTEND_OPTION_WITH_MARSHALLING( \
2653 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2654 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2655 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2656 MERGER, EXTRACTOR, TABLE_INDEX) \
2657 PARSE_OPTION_WITH_MARSHALLING( \
2658 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2659 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2660 #include "clang/Driver/Options.inc"
2661 #undef FRONTEND_OPTION_WITH_MARSHALLING
2664 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2665 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2667 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2670 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2671 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2679 Diags.
Report(diag::err_drv_invalid_value)
2680 << A->getAsString(Args) << A->getValue();
2690 Args.hasArg(OPT_interface_stub_version_EQ)
2691 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2693 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2694 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2695 ArgStr ==
"experimental-tapi-elf-v1") {
2697 "Invalid interface stub format: " + ArgStr.str() +
2699 Diags.
Report(diag::err_drv_invalid_value)
2700 <<
"Must specify a valid interface stub format type, ie: "
2701 "-interface-stub-version=ifs-v1"
2704 }
else if (!ArgStr.startswith(
"ifs-")) {
2706 "Invalid interface stub format: " + ArgStr.str() +
".";
2707 Diags.
Report(diag::err_drv_invalid_value)
2708 <<
"Must specify a valid interface stub format type, ie: "
2709 "-interface-stub-version=ifs-v1"
2718 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2719 Opts.
Plugins.emplace_back(A->getValue(0));
2723 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2724 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2727 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2729 unsigned MajorVersion;
2730 unsigned MinorVersion;
2734 MinorVersion, Hashed, UserInfo)) {
2735 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2742 std::make_shared<TestModuleFileExtension>(
2743 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2746 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2750 Diags.
Report(diag::err_drv_invalid_value)
2751 << A->getAsString(Args) << A->getValue();
2754 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2755 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2756 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2758 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2759 StringRef Val = A->getValue();
2760 if (!Val.contains(
'='))
2765 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2768 if (Args.hasArg(OPT_aux_target_cpu))
2770 if (Args.hasArg(OPT_aux_target_feature))
2775 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2776 <<
"ARC migration" <<
"ObjC migration";
2780 if (
const Arg *A = Args.getLastArg(OPT_x)) {
2781 StringRef XValue = A->getValue();
2786 bool Preprocessed = XValue.consume_back(
"-cpp-output");
2787 bool ModuleMap = XValue.consume_back(
"-module-map");
2790 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
2796 if (IsHeader || Preprocessed) {
2797 if (XValue.consume_back(
"-header-unit"))
2799 else if (XValue.consume_back(
"-system"))
2801 else if (XValue.consume_back(
"-user"))
2811 DashX = llvm::StringSwitch<InputKind>(XValue)
2828 DashX = llvm::StringSwitch<InputKind>(XValue)
2836 DashX = llvm::StringSwitch<InputKind>(XValue)
2839 .Cases(
"ast",
"pcm",
"precompiled-header",
2845 Diags.
Report(diag::err_drv_invalid_value)
2846 << A->getAsString(Args) << A->getValue();
2861 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
2864 Inputs.push_back(
"-");
2868 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
2870 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
2874 StringRef(Inputs[i]).rsplit(
'.').second);
2883 bool IsSystem =
false;
2892 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
2903 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
2904 return Driver::GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
2911 #define HEADER_SEARCH_OPTION_WITH_MARSHALLING( \
2912 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2913 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2914 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2915 MERGER, EXTRACTOR, TABLE_INDEX) \
2916 GENERATE_OPTION_WITH_MARSHALLING( \
2917 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2918 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2919 #include "clang/Driver/Options.inc"
2920 #undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
2932 GenerateArg(Args, OPT_fprebuilt_module_path, Path, SA);
2935 GenerateArg(Args, OPT_fmodules_ignore_macro, Macro.val(), SA);
2941 return llvm::is_contained(Groups, Entry.
Group) &&
2942 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
2943 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
2953 OptSpecifier Opt = [It, Matches]() {
2962 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
2978 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
2990 GenerateArg(Args, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
2995 GenerateArg(Args, OPT_iframeworkwithsysroot, It->Path, SA);
3003 GenerateArg(Args, OPT_objc_isystem, It->Path, SA);
3005 GenerateArg(Args, OPT_objcxx_isystem, It->Path, SA);
3015 ? OPT_internal_isystem
3016 : OPT_internal_externc_isystem;
3020 assert(It ==
End &&
"Unhandled HeaderSearchOption::Entry.");
3024 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3025 : OPT_no_system_header_prefix;
3040 #define HEADER_SEARCH_OPTION_WITH_MARSHALLING( \
3041 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
3042 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
3043 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
3044 MERGER, EXTRACTOR, TABLE_INDEX) \
3045 PARSE_OPTION_WITH_MARSHALLING( \
3046 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
3047 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
3048 #include "clang/Driver/Options.inc"
3049 #undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3051 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3052 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3056 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3057 if (WorkingDir.empty())
3058 llvm::sys::fs::make_absolute(
P);
3060 llvm::sys::fs::make_absolute(WorkingDir,
P);
3062 llvm::sys::path::remove_dots(
P);
3066 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3067 StringRef Val = A->getValue();
3068 if (Val.contains(
'=')) {
3069 auto Split = Val.split(
'=');
3074 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3077 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3078 StringRef MacroDef = A->getValue();
3080 llvm::CachedHashString(MacroDef.split(
'=').first));
3084 bool IsIndexHeaderMap =
false;
3085 bool IsSysrootSpecified =
3086 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3087 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3088 if (A->getOption().matches(OPT_index_header_map)) {
3090 IsIndexHeaderMap =
true;
3097 bool IsFramework = A->getOption().matches(OPT_F);
3100 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3102 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3103 llvm::StringRef(A->getValue()).substr(1));
3109 IsIndexHeaderMap =
false;
3113 StringRef Prefix =
"";
3114 for (
const auto *A :
3115 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3116 if (A->getOption().matches(OPT_iprefix))
3117 Prefix = A->getValue();
3118 else if (A->getOption().matches(OPT_iwithprefix))
3124 for (
const auto *A : Args.filtered(OPT_idirafter))
3126 for (
const auto *A : Args.filtered(OPT_iquote))
3128 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
3130 !A->getOption().matches(OPT_iwithsysroot));
3131 for (
const auto *A : Args.filtered(OPT_iframework))
3133 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3138 for (
const auto *A : Args.filtered(OPT_c_isystem))
3140 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3142 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3144 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3148 for (
const auto *A :
3149 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3151 if (A->getOption().matches(OPT_internal_externc_isystem))
3157 for (
const auto *A :
3158 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3160 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3162 for (
const auto *A : Args.filtered(OPT_ivfsoverlay))
3174 llvm_unreachable(
"should not parse language flags for this input");
3210 llvm_unreachable(
"unexpected input language");
3219 return "Objective-C";
3223 return "Objective-C++";
3227 return "C++ for OpenCL";
3231 return "RenderScript";
3246 llvm_unreachable(
"unknown input language");
3249 void CompilerInvocation::GenerateLangArgs(
const LangOptions &Opts,
3255 if (Opts.ObjCAutoRefCount)
3257 if (Opts.PICLevel != 0)
3258 GenerateArg(Args, OPT_pic_level, Twine(Opts.PICLevel), SA);
3262 GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
3267 OptSpecifier StdOpt;
3269 case LangStandard::lang_opencl10:
3270 case LangStandard::lang_opencl11:
3271 case LangStandard::lang_opencl12:
3272 case LangStandard::lang_opencl20:
3273 case LangStandard::lang_opencl30:
3274 case LangStandard::lang_openclcpp10:
3275 case LangStandard::lang_openclcpp2021:
3276 StdOpt = OPT_cl_std_EQ;
3279 StdOpt = OPT_std_EQ;
3286 if (Opts.IncludeDefaultHeader)
3287 GenerateArg(Args, OPT_finclude_default_header, SA);
3288 if (Opts.DeclareOpenCLBuiltins)
3289 GenerateArg(Args, OPT_fdeclare_opencl_builtins, SA);
3293 #define LANG_OPTION_WITH_MARSHALLING( \
3294 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
3295 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
3296 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
3297 MERGER, EXTRACTOR, TABLE_INDEX) \
3298 GENERATE_OPTION_WITH_MARSHALLING( \
3299 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
3300 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
3301 #include "clang/Driver/Options.inc"
3302 #undef LANG_OPTION_WITH_MARSHALLING
3313 else if (Opts.ObjCAutoRefCount == 1)
3316 if (Opts.ObjCWeakRuntime)
3317 GenerateArg(Args, OPT_fobjc_runtime_has_weak, SA);
3322 if (Opts.ObjCSubscriptingLegacyRuntime)
3323 GenerateArg(Args, OPT_fobjc_subscripting_legacy_runtime, SA);
3326 if (Opts.GNUCVersion != 0) {
3327 unsigned Major = Opts.GNUCVersion / 100 / 100;
3328 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3329 unsigned Patch = Opts.GNUCVersion % 100;
3331 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch), SA);
3334 if (Opts.IgnoreXCOFFVisibility)
3335 GenerateArg(Args, OPT_mignore_xcoff_visibility, SA);
3344 if (Opts.MSCompatibilityVersion != 0) {
3345 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3346 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3347 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3349 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor), SA);
3352 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS()) {
3353 if (!Opts.Trigraphs)
3360 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3363 if (Opts.ConvergentFunctions &&
3364 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice))
3367 if (Opts.NoBuiltin && !Opts.Freestanding)
3370 if (!Opts.NoBuiltin)
3374 if (Opts.LongDoubleSize == 128)
3376 else if (Opts.LongDoubleSize == 64)
3378 else if (Opts.LongDoubleSize == 80)
3385 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3388 if (Opts.OpenMP != 50)
3389 GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3391 if (!Opts.OpenMPUseTLS)
3394 if (Opts.OpenMPIsDevice)
3397 if (Opts.OpenMPIRBuilder)
3398 GenerateArg(Args, OPT_fopenmp_enable_irbuilder, SA);
3401 if (Opts.OpenMPSimd) {
3404 if (Opts.OpenMP != 50)
3405 GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3408 if (Opts.OpenMPThreadSubscription)
3409 GenerateArg(Args, OPT_fopenmp_assume_threads_oversubscription, SA);
3411 if (Opts.OpenMPTeamSubscription)
3412 GenerateArg(Args, OPT_fopenmp_assume_teams_oversubscription, SA);
3414 if (Opts.OpenMPTargetDebug != 0)
3416 Twine(Opts.OpenMPTargetDebug), SA);
3418 if (Opts.OpenMPCUDANumSMs != 0)
3419 GenerateArg(Args, OPT_fopenmp_cuda_number_of_sm_EQ,
3420 Twine(Opts.OpenMPCUDANumSMs), SA);
3422 if (Opts.OpenMPCUDABlocksPerSM != 0)
3423 GenerateArg(Args, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3424 Twine(Opts.OpenMPCUDABlocksPerSM), SA);
3426 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3427 GenerateArg(Args, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3428 Twine(Opts.OpenMPCUDAReductionBufNum), SA);
3432 llvm::raw_string_ostream
OS(Targets);
3435 [&OS](
const llvm::Triple &T) { OS << T.str(); },
",");
3442 if (Opts.OpenMPCUDAMode)
3445 if (Opts.OpenMPCUDAForceFullRuntime)
3446 GenerateArg(Args, OPT_fopenmp_cuda_force_full_runtime, SA);
3458 GenerateArg(Args, OPT_ffp_contract,
"fast-honor-pragmas", SA);
3461 GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
3465 GenerateArg(Args, OPT_fsanitize_ignorelist_EQ, F, SA);
3468 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"3.8", SA);
3470 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"4.0", SA);
3472 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"6.0", SA);
3474 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"7.0", SA);
3476 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"9.0", SA);
3478 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"11.0", SA);
3480 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"12.0", SA);
3482 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"14.0", SA);
3484 if (Opts.getSignReturnAddressScope() ==
3486 GenerateArg(Args, OPT_msign_return_address_EQ,
"all", SA);
3487 else if (Opts.getSignReturnAddressScope() ==
3489 GenerateArg(Args, OPT_msign_return_address_EQ,
"non-leaf", SA);
3491 if (Opts.getSignReturnAddressKey() ==
3493 GenerateArg(Args, OPT_msign_return_address_key_EQ,
"b_key", SA);
3499 if (Opts.RelativeCXXABIVTables)
3500 GenerateArg(Args, OPT_fexperimental_relative_cxx_abi_vtables, SA);
3502 GenerateArg(Args, OPT_fno_experimental_relative_cxx_abi_vtables, SA);
3510 GenerateArg(Args, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second, SA);
3516 bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3518 std::vector<std::string> &Includes,
3527 if (Args.hasArg(OPT_fobjc_arc))
3528 Opts.ObjCAutoRefCount = 1;
3532 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3544 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3547 Diags.
Report(diag::err_drv_invalid_value)
3548 << A->getAsString(Args) << A->getValue();
3550 for (
unsigned KindValue = 0;
3556 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3557 Diag <<
Std.getName() <<
Std.getDescription();
3558 unsigned NumAliases = 0;
3559 #define LANGSTANDARD(id, name, lang, desc, features)
3560 #define LANGSTANDARD_ALIAS(id, alias) \
3561 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3562 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
3563 #include "clang/Basic/LangStandards.def"
3565 #define LANGSTANDARD(id, name, lang, desc, features)
3566 #define LANGSTANDARD_ALIAS(id, alias) \
3567 if (KindValue == LangStandard::lang_##id) Diag << alias;
3568 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
3569 #include "clang/Basic/LangStandards.def"
3577 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3585 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3587 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3588 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3589 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3590 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3591 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3592 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3593 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3594 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
3595 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
3596 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
3600 Diags.
Report(diag::err_drv_invalid_value)
3601 << A->getAsString(Args) << A->getValue();
3604 LangStd = OpenCLLangStd;
3608 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3609 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3617 #define LANG_OPTION_WITH_MARSHALLING( \
3618 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
3619 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
3620 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
3621 MERGER, EXTRACTOR, TABLE_INDEX) \
3622 PARSE_OPTION_WITH_MARSHALLING( \
3623 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
3624 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
3625 #include "clang/Driver/Options.inc"
3626 #undef LANG_OPTION_WITH_MARSHALLING
3628 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3629 StringRef Name = A->getValue();
3630 if (Name ==
"full" || Name ==
"branch") {
3631 Opts.CFProtectionBranch = 1;
3635 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3636 !Args.hasArg(OPT_sycl_std_EQ)) {
3646 if (Arg *
arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3647 StringRef value =
arg->getValue();
3649 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3652 if (Args.hasArg(OPT_fobjc_gc_only))
3654 else if (Args.hasArg(OPT_fobjc_gc))
3656 else if (Args.hasArg(OPT_fobjc_arc)) {
3657 Opts.ObjCAutoRefCount = 1;
3659 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3666 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3667 Opts.ObjCWeakRuntime = 1;
3673 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3674 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3675 assert(!Opts.ObjCWeak);
3677 Diags.
Report(diag::err_objc_weak_with_gc);
3678 }
else if (!Opts.ObjCWeakRuntime) {
3679 Diags.
Report(diag::err_objc_weak_unsupported);
3683 }
else if (Opts.ObjCAutoRefCount) {
3684 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3687 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3688 Opts.ObjCSubscriptingLegacyRuntime =
3692 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
3695 VersionTuple GNUCVer;
3696 bool Invalid = GNUCVer.tryParse(A->getValue());
3697 unsigned Major = GNUCVer.getMajor();
3698 unsigned Minor = GNUCVer.getMinor().value_or(0);
3699 unsigned Patch = GNUCVer.getSubminor().value_or(0);
3700 if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
3701 Diags.
Report(diag::err_drv_invalid_value)
3702 << A->getAsString(Args) << A->getValue();
3704 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
3707 if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
3708 Opts.IgnoreXCOFFVisibility = 1;
3710 if (Args.hasArg(OPT_ftrapv)) {
3714 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
3716 else if (Args.hasArg(OPT_fwrapv))
3719 Opts.MSCompatibilityVersion = 0;
3720 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
3722 if (VT.tryParse(A->getValue()))
3723 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3725 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
3726 VT.getMinor().value_or(0) * 100000 +
3727 VT.getSubminor().value_or(0);
3735 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS();
3737 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
3739 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
3740 && Opts.OpenCLVersion == 200);
3742 Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
3743 Opts.SYCLIsDevice ||
3744 Args.hasArg(OPT_fconvergent_functions);
3746 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
3747 if (!Opts.NoBuiltin)
3749 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
3750 if (A->getOption().matches(options::OPT_mlong_double_64))
3751 Opts.LongDoubleSize = 64;
3752 else if (A->getOption().matches(options::OPT_mlong_double_80))
3753 Opts.LongDoubleSize = 80;
3754 else if (A->getOption().matches(options::OPT_mlong_double_128))
3755 Opts.LongDoubleSize = 128;
3757 Opts.LongDoubleSize = 0;
3759 if (Opts.FastRelaxedMath)
3765 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3767 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3768 << A->getSpelling() <<
"-fdefault-calling-conv";
3770 if (T.getArch() != llvm::Triple::x86)
3771 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3772 << A->getSpelling() << T.getTriple();
3779 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 50 : 0;
3781 bool IsSimdSpecified =
3782 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
3784 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
3786 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
3787 Opts.OpenMPIsDevice =
3788 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
3789 Opts.OpenMPIRBuilder =
3790 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
3791 bool IsTargetSpecified =
3792 Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
3794 Opts.ConvergentFunctions = Opts.ConvergentFunctions || Opts.OpenMPIsDevice;
3796 if (Opts.OpenMP || Opts.OpenMPSimd) {
3798 Args, OPT_fopenmp_version_EQ,
3799 (IsSimdSpecified || IsTargetSpecified) ? 50 : Opts.OpenMP, Diags))
3800 Opts.OpenMP = Version;
3803 if (!Opts.OpenMPIsDevice) {
3804 switch (T.getArch()) {
3808 case llvm::Triple::nvptx:
3809 case llvm::Triple::nvptx64:
3810 Diags.
Report(diag::err_drv_omp_host_target_not_supported) << T.str();
3818 if ((Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN())) ||
3819 Opts.OpenCLCPlusPlus) {
3821 Opts.Exceptions = 0;
3822 Opts.CXXExceptions = 0;
3824 if (Opts.OpenMPIsDevice && T.isNVPTX()) {
3825 Opts.OpenMPCUDANumSMs =
3827 Opts.OpenMPCUDANumSMs, Diags);
3828 Opts.OpenMPCUDABlocksPerSM =
3830 Opts.OpenMPCUDABlocksPerSM, Diags);
3832 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3833 Opts.OpenMPCUDAReductionBufNum, Diags);
3838 if (Opts.OpenMPIsDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
3839 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
3841 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
3842 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
3843 Opts.OpenMPTargetDebug = 1;
3846 if (Opts.OpenMPIsDevice) {
3847 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
3848 Opts.OpenMPTeamSubscription =
true;
3849 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
3850 Opts.OpenMPThreadSubscription =
true;
3854 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
3855 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
3856 auto getArchPtrSize = [](
const llvm::Triple &T) {
3857 if (T.isArch16Bit())
3859 if (T.isArch32Bit())
3861 assert(T.isArch64Bit() &&
"Expected 64-bit architecture");
3865 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
3866 llvm::Triple TT(A->getValue(i));
3868 if (TT.getArch() == llvm::Triple::UnknownArch ||
3869 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
3870 TT.getArch() == llvm::Triple::nvptx ||
3871 TT.getArch() == llvm::Triple::nvptx64 ||
3872 TT.getArch() == llvm::Triple::amdgcn ||
3873 TT.getArch() == llvm::Triple::x86 ||
3874 TT.getArch() == llvm::Triple::x86_64))
3875 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
3876 else if (getArchPtrSize(T) != getArchPtrSize(TT))
3877 Diags.
Report(diag::err_drv_incompatible_omp_arch)
3878 << A->getValue(i) << T.str();
3886 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
3889 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
3894 Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) &&
3895 Args.hasArg(options::OPT_fopenmp_cuda_mode);
3898 Opts.OpenMPCUDAForceFullRuntime =
3899 Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) &&
3900 Args.hasArg(options::OPT_fopenmp_cuda_force_full_runtime);
3905 Opts.Optimize = Opt != 0;
3906 Opts.OptimizeSize = OptSize != 0;
3911 Opts.NoInlineDefine = !Opts.Optimize;
3912 if (Arg *InlineArg = Args.getLastArg(
3913 options::OPT_finline_functions, options::OPT_finline_hint_functions,
3914 options::OPT_fno_inline_functions, options::OPT_fno_inline))
3915 if (InlineArg->getOption().matches(options::OPT_fno_inline))
3916 Opts.NoInlineDefine =
true;
3918 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
3919 StringRef Val = A->getValue();
3922 else if (Val ==
"on")
3924 else if (Val ==
"off")
3926 else if (Val ==
"fast-honor-pragmas")
3929 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
3935 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
3936 std::vector<std::string> systemIgnorelists =
3937 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
3939 systemIgnorelists.begin(),
3940 systemIgnorelists.end());
3942 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
3945 StringRef Ver = A->getValue();
3946 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
3947 unsigned Major, Minor = 0;
3951 if (!VerParts.first.startswith(
"0") &&
3952 !VerParts.first.getAsInteger(10, Major) &&
3953 3 <= Major && Major <= CLANG_VERSION_MAJOR &&
3954 (Major == 3 ? VerParts.second.size() == 1 &&
3955 !VerParts.second.getAsInteger(10, Minor)
3956 : VerParts.first.size() == Ver.size() ||
3957 VerParts.second ==
"0")) {
3959 if (Major == 3 && Minor <= 8)
3961 else if (Major <= 4)
3963 else if (Major <= 6)
3965 else if (Major <= 7)
3967 else if (Major <= 9)
3969 else if (Major <= 11)
3971 else if (Major <= 12)
3973 else if (Major <= 14)
3975 }
else if (Ver !=
"latest") {
3976 Diags.
Report(diag::err_drv_invalid_value)
3977 << A->getAsString(Args) << A->getValue();
3981 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
3982 StringRef SignScope = A->getValue();
3984 if (SignScope.equals_insensitive(
"none"))
3985 Opts.setSignReturnAddressScope(
3987 else if (SignScope.equals_insensitive(
"all"))
3988 Opts.setSignReturnAddressScope(
3990 else if (SignScope.equals_insensitive(
"non-leaf"))
3991 Opts.setSignReturnAddressScope(
3994 Diags.
Report(diag::err_drv_invalid_value)
3995 << A->getAsString(Args) << SignScope;
3997 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
3998 StringRef SignKey = A->getValue();
3999 if (!SignScope.empty() && !SignKey.empty()) {
4000 if (SignKey.equals_insensitive(
"a_key"))
4001 Opts.setSignReturnAddressKey(
4003 else if (SignKey.equals_insensitive(
"b_key"))
4004 Opts.setSignReturnAddressKey(
4007 Diags.
Report(diag::err_drv_invalid_value)
4008 << A->getAsString(Args) << SignKey;
4014 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4021 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI << T.str();
4027 Opts.RelativeCXXABIVTables =
4028 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4029 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4032 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4033 auto Split = StringRef(A).split(
'=');
4039 !Args.getLastArg(OPT_fno_file_reproducible) &&
4040 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4041 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4042 Args.getLastArg(OPT_ffile_reproducible));
4045 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4047 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4048 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4051 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4052 std::ifstream SeedFile(A->getValue(0));
4054 if (!SeedFile.is_open())
4055 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4061 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4110 llvm_unreachable(
"invalid frontend action");
4121 #define PREPROCESSOR_OPTION_WITH_MARSHALLING( \
4122 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4123 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4124 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4125 MERGER, EXTRACTOR, TABLE_INDEX) \
4126 GENERATE_OPTION_WITH_MARSHALLING( \
4127 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
4128 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4129 #include "clang/Driver/Options.inc"
4130 #undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4133 GenerateArg(Args, OPT_pch_through_hdrstop_use, SA);
4136 GenerateArg(Args, OPT_error_on_deserialized_pch_decl, D, SA);
4144 for (
const auto &M : Opts.
Macros) {
4147 if (M.first ==
"__CET__=1" && !M.second &&
4148 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4150 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4151 !CodeGenOpts.CFProtectionBranch)
4153 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4154 CodeGenOpts.CFProtectionBranch)
4157 GenerateArg(Args, M.second ? OPT_U : OPT_D, M.first, SA);
4160 for (
const auto &I : Opts.
Includes) {
4163 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4164 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4169 if (LangOpts.HLSL && I ==
"hlsl.h")
4179 GenerateArg(Args, OPT_remap_file, RF.first +
";" + RF.second, SA);
4193 #define PREPROCESSOR_OPTION_WITH_MARSHALLING( \
4194 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4195 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4196 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4197 MERGER, EXTRACTOR, TABLE_INDEX) \
4198 PARSE_OPTION_WITH_MARSHALLING( \
4199 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
4200 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
4201 #include "clang/Driver/Options.inc"
4202 #undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4204 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4205 Args.hasArg(OPT_pch_through_hdrstop_use);
4207 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4210 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4211 StringRef
Value(A->getValue());
4212 size_t Comma =
Value.find(
',');
4214 unsigned EndOfLine = 0;
4216 if (Comma == StringRef::npos ||
4217 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4218 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4219 Diags.
Report(diag::err_drv_preamble_format);
4227 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4228 StringRef Name = A->getValue();
4229 if (Name ==
"branch")
4231 else if (Name ==
"return")
4233 else if (Name ==
"full")
4238 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4239 if (A->getOption().matches(OPT_D))
4246 for (
const auto *A : Args.filtered(OPT_include))
4247 Opts.
Includes.emplace_back(A->getValue());
4249 for (
const auto *A : Args.filtered(OPT_chain_include))
4252 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4253 std::pair<StringRef, StringRef>
Split = StringRef(A->getValue()).split(
';');
4255 if (
Split.second.empty()) {
4256 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4277 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING( \
4278 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4279 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4280 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4281 MERGER, EXTRACTOR, TABLE_INDEX) \
4282 GENERATE_OPTION_WITH_MARSHALLING( \
4283 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
4284 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4285 #include "clang/Driver/Options.inc"
4286 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4304 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING( \
4305 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4306 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4307 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4308 MERGER, EXTRACTOR, TABLE_INDEX) \
4309 PARSE_OPTION_WITH_MARSHALLING( \
4310 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
4311 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
4312 #include "clang/Driver/Options.inc"
4313 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4316 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4326 #define TARGET_OPTION_WITH_MARSHALLING( \
4327 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4328 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4329 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4330 MERGER, EXTRACTOR, TABLE_INDEX) \
4331 GENERATE_OPTION_WITH_MARSHALLING( \
4332 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
4333 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4334 #include "clang/Driver/Options.inc"
4335 #undef TARGET_OPTION_WITH_MARSHALLING
4341 GenerateArg(Args, OPT_darwin_target_variant_sdk_version_EQ,
4351 #define TARGET_OPTION_WITH_MARSHALLING( \
4352 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4353 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4354 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4355 MERGER, EXTRACTOR, TABLE_INDEX) \
4356 PARSE_OPTION_WITH_MARSHALLING( \
4357 Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
4358 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
4359 #include "clang/Driver/Options.inc"
4360 #undef TARGET_OPTION_WITH_MARSHALLING
4362 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4363 llvm::VersionTuple Version;
4364 if (Version.tryParse(A->getValue()))
4365 Diags.
Report(diag::err_drv_invalid_value)
4366 << A->getAsString(Args) << A->getValue();
4371 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4372 llvm::VersionTuple Version;
4373 if (Version.tryParse(A->getValue()))
4374 Diags.
Report(diag::err_drv_invalid_value)
4375 << A->getAsString(Args) << A->getValue();
4383 bool CompilerInvocation::CreateFromArgsImpl(
4391 unsigned MissingArgIndex, MissingArgCount;
4392 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4393 MissingArgCount, IncludedFlagsBitmask);
4397 if (MissingArgCount)
4398 Diags.
Report(diag::err_drv_missing_argument)
4399 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4402 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4403 auto ArgString = A->getAsString(Args);
4405 if (Opts.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
4406 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4408 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4409 << ArgString << Nearest;
4431 if (Warning ==
"misexpect" &&
4455 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4456 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4457 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4458 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4471 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4477 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4492 const char *Argv0) {
4498 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
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);
4597 uint64_t Hash = Result.high() ^ Result.low();
4626 llvm::vfs::getRealFileSystem());
4639 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
4640 Result->getBufferForFile(
File);
4642 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
4647 std::move(Buffer.get()),
nullptr,
File,
4650 Diags.
Report(diag::err_invalid_vfs_overlay) <<
File;