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/Host.h"
82 #include "llvm/Support/MathExtras.h"
83 #include "llvm/Support/MemoryBuffer.h"
84 #include "llvm/Support/Path.h"
85 #include "llvm/Support/Process.h"
86 #include "llvm/Support/Regex.h"
87 #include "llvm/Support/VersionTuple.h"
88 #include "llvm/Support/VirtualFileSystem.h"
89 #include "llvm/Support/raw_ostream.h"
90 #include "llvm/Target/TargetOptions.h"
99 #include <type_traits>
103 using namespace clang;
104 using namespace driver;
105 using namespace options;
131 #define SIMPLE_ENUM_VALUE_TABLE
132 #include "clang/Driver/Options.inc"
133 #undef SIMPLE_ENUM_VALUE_TABLE
138 if (Args.hasArg(Opt))
147 if (Args.hasArg(Opt))
157 const char *Spelling,
159 Option::OptionClass,
unsigned, ...) {
160 Args.push_back(Spelling);
164 return !std::is_same<T, uint64_t>::value &&
165 llvm::is_integral_or_enum<T>::value;
168 template <
typename T,
169 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
171 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
173 if (Args.hasArg(Opt))
179 template <
typename T,
180 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
186 OptSpecifier OtherOpt) {
187 return [
Value, OtherValue, OtherOpt](OptSpecifier Opt,
unsigned,
190 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
191 return A->getOption().matches(Opt) ?
Value : OtherValue;
201 if (KeyPath ==
Value)
202 Args.push_back(Spelling);
207 const char *Spelling,
209 Option::OptionClass OptClass,
unsigned,
210 const Twine &
Value) {
212 case Option::SeparateClass:
213 case Option::JoinedOrSeparateClass:
214 case Option::JoinedAndSeparateClass:
215 Args.push_back(Spelling);
216 Args.push_back(SA(
Value));
218 case Option::JoinedClass:
219 case Option::CommaJoinedClass:
220 Args.push_back(SA(Twine(Spelling) +
Value));
223 llvm_unreachable(
"Cannot denormalize an option with option class "
224 "incompatible with string denormalization.");
228 template <
typename T>
232 Option::OptionClass OptClass,
unsigned TableIndex, T
Value) {
238 for (
int I = 0, E = Table.Size; I != E; ++I)
239 if (Name == Table.Table[I].Name)
240 return Table.Table[I];
247 for (
int I = 0, E = Table.Size; I != E; ++I)
248 if (
Value == Table.Table[I].Value)
249 return Table.Table[I];
257 assert(TableIndex < SimpleEnumValueTablesSize);
258 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
260 auto *Arg = Args.getLastArg(Opt);
264 StringRef ArgValue = Arg->getValue();
266 return MaybeEnumVal->Value;
269 Diags.
Report(diag::err_drv_invalid_value)
270 << Arg->getAsString(Args) << ArgValue;
275 const char *Spelling,
277 Option::OptionClass OptClass,
278 unsigned TableIndex,
unsigned Value) {
279 assert(TableIndex < SimpleEnumValueTablesSize);
280 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
285 llvm_unreachable(
"The simple enum value was not correctly defined in "
286 "the tablegen option description");
290 template <
typename T>
292 const char *Spelling,
294 Option::OptionClass OptClass,
295 unsigned TableIndex, T
Value) {
297 static_cast<unsigned>(
Value));
304 auto *Arg = Args.getLastArg(Opt);
310 template <
typename IntTy>
314 auto *Arg = Args.getLastArg(Opt);
318 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
320 Diags.
Report(diag::err_drv_invalid_int_value)
321 << Arg->getAsString(Args) << Arg->getValue();
330 return Args.getAllArgValues(Opt);
334 const char *Spelling,
336 Option::OptionClass OptClass,
338 const std::vector<std::string> &Values) {
340 case Option::CommaJoinedClass: {
342 if (!Values.empty()) {
343 CommaJoinedValue.append(Values.front());
345 CommaJoinedValue.append(
",");
346 CommaJoinedValue.append(
Value);
350 TableIndex, CommaJoinedValue);
353 case Option::JoinedClass:
354 case Option::SeparateClass:
355 case Option::JoinedOrSeparateClass:
360 llvm_unreachable(
"Cannot denormalize an option with option class "
361 "incompatible with string vector denormalization.");
369 auto *Arg = Args.getLastArg(Opt);
375 template <
typename T,
typename U>
377 return static_cast<T
>(
Value);
381 return KeyPath |
Value;
388 template <
typename T,
typename U, U Value>
393 #define PARSE_OPTION_WITH_MARSHALLING(ARGS, DIAGS, SUCCESS, ID, FLAGS, PARAM, \
394 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
395 IMPLIED_CHECK, IMPLIED_VALUE, \
396 NORMALIZER, MERGER, TABLE_INDEX) \
397 if ((FLAGS)&options::CC1Option) { \
398 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
400 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
402 if (auto MaybeValue = \
403 NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS, SUCCESS)) \
405 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
410 #define GENERATE_OPTION_WITH_MARSHALLING( \
411 ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, \
412 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, \
414 if ((FLAGS)&options::CC1Option) { \
415 [&](const auto &Extracted) { \
418 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
419 : (DEFAULT_VALUE)))) \
420 DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class, \
421 TABLE_INDEX, Extracted); \
422 }(EXTRACTOR(KEYPATH)); \
436 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
437 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
438 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
439 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
442 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
443 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
446 llvm::Triple T(TargetOpts.
Triple);
447 llvm::Triple::ArchType Arch = T.getArch();
452 T.isWindowsMSVCEnvironment())
453 Diags.
Report(diag::err_fe_invalid_exception_model)
454 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str();
456 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
457 Diags.
Report(diag::warn_c_kext);
459 if (Args.hasArg(OPT_fconcepts_ts))
460 Diags.
Report(diag::warn_fe_concepts_ts_flag);
462 if (LangOpts.NewAlignOverride &&
463 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
464 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
465 Diags.
Report(diag::err_fe_invalid_alignment)
466 << A->getAsString(Args) << A->getValue();
467 LangOpts.NewAlignOverride = 0;
471 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
472 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
475 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
476 Diags.
Report(diag::err_drv_argument_not_allowed_with)
479 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
480 Diags.
Report(diag::warn_ignored_hip_only_option)
481 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
483 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
484 Diags.
Report(diag::warn_ignored_hip_only_option)
485 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
490 if (Args.getLastArg(OPT_cl_strict_aliasing) && LangOpts.OpenCLVersion > 100)
491 Diags.
Report(diag::warn_option_invalid_ocl_version)
493 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
495 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
496 auto DefaultCC = LangOpts.getDefaultCallingConv();
500 Arch != llvm::Triple::x86;
505 Diags.
Report(diag::err_drv_argument_not_allowed_with)
506 << A->getSpelling() << T.getTriple();
510 Diags.
Report(diag::err_drv_argument_only_allowed_with)
511 << Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args)
512 <<
"-fno-legacy-pass-manager";
526 !Args.hasArg(OPT_cl_opt_disable))
527 DefaultOpt = llvm::CodeGenOpt::Default;
529 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
530 if (A->getOption().matches(options::OPT_O0))
533 if (A->getOption().matches(options::OPT_Ofast))
534 return llvm::CodeGenOpt::Aggressive;
536 assert(A->getOption().matches(options::OPT_O));
538 StringRef S(A->getValue());
539 if (S ==
"s" || S ==
"z")
540 return llvm::CodeGenOpt::Default;
543 return llvm::CodeGenOpt::Less;
552 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
553 if (A->getOption().matches(options::OPT_O)) {
554 switch (A->getValue()[0]) {
568 llvm::opt::OptSpecifier OptSpecifier,
572 Option::OptionClass::FlagClass, 0);
576 llvm::opt::OptSpecifier OptSpecifier,
581 Opt.getKind(), 0,
Value);
608 #ifdef CLANG_ROUND_TRIP_CC1_ARGS
609 bool DoRoundTripDefault =
true;
611 bool DoRoundTripDefault =
false;
614 bool DoRoundTrip = DoRoundTripDefault;
615 for (
const auto *Arg : CommandLineArgs) {
616 if (Arg == StringRef(
"-round-trip-args"))
618 if (Arg == StringRef(
"-no-round-trip-args"))
625 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
630 llvm::raw_string_ostream OS(Buffer);
631 for (
const char *Arg : Args) {
632 llvm::sys::printArg(OS, Arg,
true);
645 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
652 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
658 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
659 Diags.
Report(diag::note_cc1_round_trip_original)
660 << SerializeArgs(CommandLineArgs);
665 llvm::BumpPtrAllocator Alloc;
666 llvm::StringSaver StringPool(Alloc);
667 auto SA = [&StringPool](
const Twine &Arg) {
668 return StringPool.save(Arg).data();
674 SmallVector<const char *> GeneratedArgs1;
675 Generate(DummyInvocation, GeneratedArgs1, SA);
681 bool Success2 = Parse(RealInvocation, GeneratedArgs1, Diags, Argv0);
686 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
687 Diags.
Report(diag::note_cc1_round_trip_generated)
688 << 1 << SerializeArgs(GeneratedArgs1);
694 SmallVector<const char *> GeneratedArgs2;
695 Generate(RealInvocation, GeneratedArgs2, SA);
700 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
701 [](
const char *AElem,
const char *BElem) {
702 return StringRef(AElem) == StringRef(BElem);
709 if (!
Equal(GeneratedArgs1, GeneratedArgs2)) {
710 Diags.
Report(diag::err_cc1_round_trip_mismatch);
711 Diags.
Report(diag::note_cc1_round_trip_generated)
712 << 1 << SerializeArgs(GeneratedArgs1);
713 Diags.
Report(diag::note_cc1_round_trip_generated)
714 << 2 << SerializeArgs(GeneratedArgs2);
718 Diags.
Report(diag::remark_cc1_round_trip_generated)
719 << 1 << SerializeArgs(GeneratedArgs1);
720 Diags.
Report(diag::remark_cc1_round_trip_generated)
721 << 2 << SerializeArgs(GeneratedArgs2);
727 OptSpecifier GroupWithValue,
728 std::vector<std::string> &Diagnostics) {
729 for (
auto *A : Args.filtered(Group)) {
730 if (A->getOption().getKind() == Option::FlagClass) {
733 Diagnostics.push_back(
734 std::string(A->getOption().getName().drop_front(1)));
735 }
else if (A->getOption().matches(GroupWithValue)) {
738 Diagnostics.push_back(
739 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
742 Diagnostics.push_back(A->getValue());
753 std::vector<std::string> &Funcs) {
754 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
755 auto BuiltinEnd = llvm::partition(Values, [](
const std::string FuncName) {
758 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
766 #define ANALYZER_OPTION_WITH_MARSHALLING( \
767 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
768 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
769 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
770 MERGER, EXTRACTOR, TABLE_INDEX) \
771 GENERATE_OPTION_WITH_MARSHALLING( \
772 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
773 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
774 #include "clang/Driver/Options.inc"
775 #undef ANALYZER_OPTION_WITH_MARSHALLING
779 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
781 GenerateArg(Args, OPT_analyzer_store, CMDFLAG, SA); \
783 #include "clang/StaticAnalyzer/Core/Analyses.def"
785 llvm_unreachable(
"Tried to generate unknown analysis store.");
791 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
793 GenerateArg(Args, OPT_analyzer_constraints, CMDFLAG, SA); \
795 #include "clang/StaticAnalyzer/Core/Analyses.def"
797 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
803 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
805 GenerateArg(Args, OPT_analyzer_output, CMDFLAG, SA); \
807 #include "clang/StaticAnalyzer/Core/Analyses.def"
809 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
815 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
817 GenerateArg(Args, OPT_analyzer_purge, CMDFLAG, SA); \
819 #include "clang/StaticAnalyzer/Core/Analyses.def"
821 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
827 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
829 GenerateArg(Args, OPT_analyzer_inlining_mode, CMDFLAG, SA); \
831 #include "clang/StaticAnalyzer/Core/Analyses.def"
833 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
839 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
846 for (
const auto &C : Opts.
Config) {
849 auto Entry = ConfigOpts.
Config.find(C.getKey());
850 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() == C.getValue())
853 GenerateArg(Args, OPT_analyzer_config, C.getKey() +
"=" + C.getValue(), SA);
864 #define ANALYZER_OPTION_WITH_MARSHALLING( \
865 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
866 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
867 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
868 MERGER, EXTRACTOR, TABLE_INDEX) \
869 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
870 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
871 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
873 #include "clang/Driver/Options.inc"
874 #undef ANALYZER_OPTION_WITH_MARSHALLING
876 if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
877 StringRef Name = A->getValue();
879 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
880 .Case(CMDFLAG, NAME##Model)
881 #include "clang/StaticAnalyzer/Core/Analyses.def"
884 Diags.
Report(diag::err_drv_invalid_value)
885 << A->getAsString(Args) << Name;
892 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
893 StringRef Name = A->getValue();
895 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
896 .Case(CMDFLAG, NAME##Model)
897 #include "clang/StaticAnalyzer/Core/Analyses.def"
900 Diags.
Report(diag::err_drv_invalid_value)
901 << A->getAsString(Args) << Name;
908 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
909 StringRef Name = A->getValue();
911 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
912 .Case(CMDFLAG, PD_##NAME)
913 #include "clang/StaticAnalyzer/Core/Analyses.def"
916 Diags.
Report(diag::err_drv_invalid_value)
917 << A->getAsString(Args) << Name;
924 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
925 StringRef Name = A->getValue();
927 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
929 #include "clang/StaticAnalyzer/Core/Analyses.def"
932 Diags.
Report(diag::err_drv_invalid_value)
933 << A->getAsString(Args) << Name;
940 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
941 StringRef Name = A->getValue();
943 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
945 #include "clang/StaticAnalyzer/Core/Analyses.def"
948 Diags.
Report(diag::err_drv_invalid_value)
949 << A->getAsString(Args) << Name;
958 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
960 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
963 StringRef CheckerAndPackageList = A->getValue();
965 CheckerAndPackageList.split(CheckersAndPackages,
",");
966 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
972 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
976 StringRef configList = A->getValue();
977 SmallVector<StringRef, 4> configVals;
978 configList.split(configVals,
",");
979 for (
const auto &configVal : configVals) {
981 std::tie(key, val) = configVal.split(
"=");
984 diag::err_analyzer_config_no_value) << configVal;
988 if (val.find(
'=') != StringRef::npos) {
990 diag::err_analyzer_config_multiple_values)
1000 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1017 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1020 os << Args.getArgString(i);
1028 StringRef OptionName, StringRef DefaultVal) {
1029 return Config.insert({OptionName,
std::string(DefaultVal)}).first->second;
1034 StringRef &OptionField, StringRef Name,
1035 StringRef DefaultVal) {
1044 bool &OptionField, StringRef Name,
bool DefaultVal) {
1045 auto PossiblyInvalidVal = llvm::StringSwitch<Optional<bool>>(
1048 .Case(
"false",
false)
1051 if (!PossiblyInvalidVal) {
1053 Diags->
Report(diag::err_analyzer_config_invalid_input)
1054 << Name <<
"a boolean";
1056 OptionField = DefaultVal;
1058 OptionField = PossiblyInvalidVal.getValue();
1063 unsigned &OptionField, StringRef Name,
1064 unsigned DefaultVal) {
1066 OptionField = DefaultVal;
1067 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1068 .getAsInteger(0, OptionField);
1069 if (Diags && HasFailed)
1070 Diags->
Report(diag::err_analyzer_config_invalid_input)
1071 << Name <<
"an unsigned";
1079 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1080 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1082 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1083 SHALLOW_VAL, DEEP_VAL) \
1084 switch (AnOpts.getUserMode()) { \
1086 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, SHALLOW_VAL); \
1089 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEEP_VAL); \
1093 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1094 #undef ANALYZER_OPTION
1095 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
1102 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1103 std::vector<StringRef> Checkers =
1105 std::vector<StringRef> Packages =
1109 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1111 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1113 bool IsChecker = CheckerOrPackage.contains(
'.');
1116 ? llvm::find(Checkers, CheckerOrPackage) != Checkers.end()
1117 : llvm::find(Packages, CheckerOrPackage) != Packages.end();
1120 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1121 << CheckerOrPackage;
1131 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1132 Diags->
Report(diag::err_analyzer_config_invalid_input)
1133 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1135 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1136 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1139 if (!AnOpts.ModelPath.empty() &&
1140 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1141 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1149 OptSpecifier OptEQ, StringRef Name,
1151 if (Remark.hasValidPattern()) {
1156 GenerateArg(Args, OPT_R_Joined, StringRef(
"no-") + Name, SA);
1165 OptSpecifier OptEQ, StringRef Name) {
1168 auto InitializeResultPattern = [&Diags, &Args, &Result](
const Arg *A) {
1169 Result.Pattern = A->getValue();
1172 Result.Regex = std::make_shared<llvm::Regex>(Result.Pattern);
1173 if (!Result.Regex->isValid(RegexError)) {
1174 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1175 << RegexError << A->getAsString(Args);
1182 for (Arg *A : Args) {
1183 if (A->getOption().matches(OPT_R_Joined)) {
1184 StringRef
Value = A->getValue();
1188 else if (
Value ==
"everything")
1190 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1192 else if (
Value ==
"no-everything")
1194 }
else if (A->getOption().matches(OptEQ)) {
1196 if (!InitializeResultPattern(A))
1203 Result.Pattern =
"";
1204 Result.Regex =
nullptr;
1211 const std::vector<std::string> &Levels,
1214 bool Success =
true;
1215 for (
const auto &
Level : Levels) {
1217 llvm::StringSwitch<DiagnosticLevelMask>(
Level)
1225 Diags.
Report(diag::err_drv_invalid_value) << FlagName <<
Level;
1233 const std::vector<std::string> &Sanitizers,
1235 for (
const auto &Sanitizer : Sanitizers) {
1238 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1245 SmallVector<StringRef, 4> Values;
1254 llvm::SplitString(Bundle, BundleParts,
",");
1255 for (
const auto &B : BundleParts) {
1259 D.
Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1273 llvm::raw_string_ostream OS(Buffer);
1274 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1280 const Twine &ProfileName) {
1283 if (
auto E = ReaderOrErr.takeError()) {
1284 llvm::consumeError(std::move(E));
1288 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1289 std::move(ReaderOrErr.get());
1290 if (PGOReader->isIRLevelProfile()) {
1291 if (PGOReader->hasCSIRLevelProfile())
1299 void CompilerInvocation::GenerateCodeGenArgs(
1301 StringAllocator SA,
const llvm::Triple &T,
const std::string &OutputFile,
1305 if (Opts.OptimizationLevel == 0)
1308 GenerateArg(Args, OPT_O, Twine(Opts.OptimizationLevel), SA);
1310 #define CODEGEN_OPTION_WITH_MARSHALLING( \
1311 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
1312 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
1313 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
1314 MERGER, EXTRACTOR, TABLE_INDEX) \
1315 GENERATE_OPTION_WITH_MARSHALLING( \
1316 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
1317 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
1318 #include "clang/Driver/Options.inc"
1319 #undef CODEGEN_OPTION_WITH_MARSHALLING
1321 if (Opts.OptimizationLevel > 0) {
1325 GenerateArg(Args, OPT_finline_hint_functions, SA);
1330 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1331 GenerateArg(Args, OPT_fdirect_access_external_data, SA);
1332 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1333 GenerateArg(Args, OPT_fno_direct_access_external_data, SA);
1336 switch (Opts.DebugInfo) {
1338 DebugInfoVal =
"line-tables-only";
1341 DebugInfoVal =
"line-directives-only";
1344 DebugInfoVal =
"constructor";
1347 DebugInfoVal =
"limited";
1350 DebugInfoVal =
"standalone";
1353 DebugInfoVal =
"unused-types";
1356 DebugInfoVal =
None;
1359 DebugInfoVal =
None;
1363 GenerateArg(Args, OPT_debug_info_kind_EQ, *DebugInfoVal, SA);
1370 Prefix.first +
"=" + Prefix.second, SA);
1374 Prefix.first +
"=" + Prefix.second, SA);
1376 if (Opts.NewStructPathTBAA)
1379 if (Opts.OptimizeSize == 1)
1381 else if (Opts.OptimizeSize == 2)
1389 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1391 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1397 if (Opts.DebugNameTable ==
1398 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1400 else if (Opts.DebugNameTable ==
1401 static_cast<unsigned>(
1402 llvm::DICompileUnit::DebugNameTableKind::Default))
1408 if (Opts.TimePasses) {
1409 if (Opts.TimePassesPerRun)
1410 GenerateArg(Args, OPT_ftime_report_EQ,
"per-pass-run", SA);
1415 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1418 if (Opts.PrepareForThinLTO)
1427 StringRef MemProfileBasename(
"memprof.profraw");
1450 if (!InstrBundle.empty())
1451 GenerateArg(Args, OPT_fxray_instrumentation_bundle, InstrBundle, SA);
1454 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1455 GenerateArg(Args, OPT_fcf_protection_EQ,
"full", SA);
1456 else if (Opts.CFProtectionReturn)
1457 GenerateArg(Args, OPT_fcf_protection_EQ,
"return", SA);
1458 else if (Opts.CFProtectionBranch)
1459 GenerateArg(Args, OPT_fcf_protection_EQ,
"branch", SA);
1462 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1463 F.PropagateAttrs && F.Internalize;
1465 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1472 if (Opts.ExplicitEmulatedTLS) {
1474 Args, Opts.EmulatedTLS ? OPT_femulated_tls : OPT_fno_emulated_tls, SA);
1486 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1490 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1494 if (Opts.EnableAIXExtendedAltivecABI)
1512 GenerateArg(Args, OPT_fdiagnostics_hotness_threshold_EQ,
1519 GenerateArg(Args, OPT_fsanitize_recover_EQ, Sanitizer, SA);
1522 GenerateArg(Args, OPT_fsanitize_trap_EQ, Sanitizer, SA);
1524 if (!Opts.EmitVersionIdentMetadata)
1527 switch (Opts.FiniteLoops) {
1530 case CodeGenOptions::FiniteLoopsKind::Always:
1533 case CodeGenOptions::FiniteLoopsKind::Never:
1539 bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1542 const llvm::Triple &T,
1551 unsigned MaxOptLevel = 3;
1552 if (OptimizationLevel > MaxOptLevel) {
1555 Diags.
Report(diag::warn_drv_optimization_value)
1556 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1557 OptimizationLevel = MaxOptLevel;
1559 Opts.OptimizationLevel = OptimizationLevel;
1568 #define CODEGEN_OPTION_WITH_MARSHALLING( \
1569 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
1570 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
1571 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
1572 MERGER, EXTRACTOR, TABLE_INDEX) \
1573 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
1574 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
1575 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
1576 MERGER, TABLE_INDEX)
1577 #include "clang/Driver/Options.inc"
1578 #undef CODEGEN_OPTION_WITH_MARSHALLING
1582 Opts.setInlining((Opts.OptimizationLevel == 0)
1587 if (Arg *InlineArg = Args.getLastArg(
1588 options::OPT_finline_functions, options::OPT_finline_hint_functions,
1589 options::OPT_fno_inline_functions, options::OPT_fno_inline)) {
1590 if (Opts.OptimizationLevel > 0) {
1591 const Option &InlineOpt = InlineArg->getOption();
1592 if (InlineOpt.matches(options::OPT_finline_functions))
1594 else if (InlineOpt.matches(options::OPT_finline_hint_functions))
1603 Opts.DirectAccessExternalData =
1604 Args.hasArg(OPT_fdirect_access_external_data) ||
1605 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1608 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1610 llvm::StringSwitch<unsigned>(A->getValue())
1619 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1627 if (Args.getLastArg(OPT_fuse_ctor_homing))
1631 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1632 auto Split = StringRef(Arg).split(
'=');
1637 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1638 auto Split = StringRef(Arg).split(
'=');
1643 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1644 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1645 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1646 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1649 llvm::is_contained(DebugEntryValueArchs, T.getArch()))
1650 Opts.EmitCallSiteInfo =
true;
1653 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1658 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1659 Args.hasArg(OPT_new_struct_path_tbaa);
1661 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1662 if (Opts.SimplifyLibCalls)
1665 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1666 (Opts.OptimizationLevel > 1));
1668 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1670 Opts.DebugNameTable =
static_cast<unsigned>(
1671 Args.hasArg(OPT_ggnu_pubnames)
1672 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1673 : Args.hasArg(OPT_gpubnames)
1674 ? llvm::DICompileUnit::DebugNameTableKind::Default
1680 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1681 Opts.TimePasses =
true;
1684 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1685 if (Opts.LegacyPassManager)
1686 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1687 << A->getAsString(Args) <<
"-fno-legacy-pass-manager";
1689 StringRef Val = A->getValue();
1690 if (Val ==
"per-pass")
1691 Opts.TimePassesPerRun =
false;
1692 else if (Val ==
"per-pass-run")
1693 Opts.TimePassesPerRun =
true;
1695 Diags.
Report(diag::err_drv_invalid_value)
1696 << A->getAsString(Args) << A->getValue();
1700 Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
1701 Opts.PrepareForThinLTO =
false;
1702 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1703 StringRef S = A->getValue();
1705 Opts.PrepareForThinLTO =
true;
1706 else if (S !=
"full")
1707 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1709 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1711 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1712 << A->getAsString(Args) <<
"-x ir";
1714 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1716 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1718 llvm::StringSwitch<std::string>(A->getValue())
1719 .Case(
"obj", OutputFile)
1720 .Default(llvm::sys::path::filename(OutputFile).str());
1723 const char *MemProfileBasename =
"memprof.profraw";
1724 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1726 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1727 llvm::sys::path::append(Path, MemProfileBasename);
1729 }
else if (Args.hasArg(OPT_fmemory_profile))
1733 if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
1734 if (Args.hasArg(OPT_coverage_version_EQ)) {
1735 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1736 if (CoverageVersion.size() != 4) {
1737 Diags.
Report(diag::err_drv_invalid_value)
1738 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1748 for (
const auto &A : Args) {
1750 if (A->getOption().getID() == options::OPT_o ||
1751 A->getOption().getID() == options::OPT_INPUT ||
1752 A->getOption().getID() == options::OPT_x ||
1753 A->getOption().getID() == options::OPT_fembed_bitcode ||
1754 A->getOption().matches(options::OPT_W_Group))
1757 A->render(Args, ASL);
1758 for (
const auto &
arg : ASL) {
1759 StringRef ArgStr(
arg);
1760 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1766 auto XRayInstrBundles =
1767 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1768 if (XRayInstrBundles.empty())
1771 for (
const auto &A : XRayInstrBundles)
1775 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1776 StringRef Name = A->getValue();
1777 if (Name ==
"full") {
1778 Opts.CFProtectionReturn = 1;
1779 Opts.CFProtectionBranch = 1;
1780 }
else if (Name ==
"return")
1781 Opts.CFProtectionReturn = 1;
1782 else if (Name ==
"branch")
1783 Opts.CFProtectionBranch = 1;
1784 else if (Name !=
"none") {
1785 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1791 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1794 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1795 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1804 if (Args.getLastArg(OPT_femulated_tls) ||
1805 Args.getLastArg(OPT_fno_emulated_tls)) {
1806 Opts.ExplicitEmulatedTLS =
true;
1809 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1810 StringRef Val = A->getValue();
1813 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1816 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
1817 StringRef Val = A->getValue();
1820 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1826 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
1827 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
1831 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
1832 << A->getSpelling() << T.str();
1834 const Option &O = A->getOption();
1835 if (O.matches(OPT_fpcc_struct_return) ||
1836 O.matches(OPT_maix_struct_return)) {
1839 assert(O.matches(OPT_freg_struct_return) ||
1840 O.matches(OPT_msvr4_struct_return));
1846 Args.getLastArg(OPT_mabi_EQ_vec_default, OPT_mabi_EQ_vec_extabi)) {
1848 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
1849 << A->getSpelling() << T.str();
1851 const Option &O = A->getOption();
1852 if (O.matches(OPT_mabi_EQ_vec_default))
1853 Diags.
Report(diag::err_aix_default_altivec_abi)
1854 << A->getSpelling() << T.str();
1856 assert(O.matches(OPT_mabi_EQ_vec_extabi));
1857 Opts.EnableAIXExtendedAltivecABI = 1;
1861 bool NeedLocTracking =
false;
1864 NeedLocTracking =
true;
1866 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
1868 NeedLocTracking =
true;
1871 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
1873 NeedLocTracking =
true;
1883 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
1890 bool UsingProfile = UsingSampleProfile ||
1893 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
1896 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1897 <<
"-fdiagnostics-show-hotness";
1901 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
1903 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
1906 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
1907 <<
"-fdiagnostics-hotness-threshold=";
1913 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1914 <<
"-fdiagnostics-hotness-threshold=";
1921 if (UsingSampleProfile)
1922 NeedLocTracking =
true;
1932 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
1935 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
1938 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
1940 if (Args.hasArg(options::OPT_ffinite_loops))
1941 Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Always;
1942 else if (Args.hasArg(options::OPT_fno_finite_loops))
1943 Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Never;
1953 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING( \
1954 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
1955 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
1956 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
1957 MERGER, EXTRACTOR, TABLE_INDEX) \
1958 GENERATE_OPTION_WITH_MARSHALLING( \
1959 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
1960 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
1961 #include "clang/Driver/Options.inc"
1962 #undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
1967 for (
const auto &Dep : Opts.
ExtraDeps) {
1968 switch (Dep.second) {
1981 GenerateArg(Args, OPT_fdepfile_entry, Dep.first, SA);
1990 bool ShowLineMarkers) {
1992 bool Success =
true;
1995 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING( \
1996 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
1997 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
1998 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
1999 MERGER, EXTRACTOR, TABLE_INDEX) \
2000 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
2001 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2002 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
2003 MERGER, TABLE_INDEX)
2004 #include "clang/Driver/Options.inc"
2005 #undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2007 if (Args.hasArg(OPT_show_includes)) {
2022 if (!Args.hasArg(OPT_fno_sanitize_blacklist)) {
2023 for (
const auto *A : Args.filtered(OPT_fsanitize_blacklist)) {
2024 StringRef Val = A->getValue();
2025 if (Val.find(
'=') == StringRef::npos)
2029 for (
const auto *A : Args.filtered(OPT_fsanitize_system_blacklist)) {
2030 StringRef Val = A->getValue();
2031 if (Val.find(
'=') == StringRef::npos)
2038 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2042 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2046 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2047 StringRef Val = A->getValue();
2048 if (Val.find(
'=') == StringRef::npos)
2052 return Success && Diags.
getNumErrors() == NumErrorsBefore;
2064 } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2065 for (
auto *A : Args) {
2066 const Option &O = A->getOption();
2067 if (O.matches(options::OPT_fcolor_diagnostics) ||
2068 O.matches(options::OPT_fdiagnostics_color)) {
2069 ShowColors = Colors_On;
2070 }
else if (O.matches(options::OPT_fno_color_diagnostics) ||
2071 O.matches(options::OPT_fno_diagnostics_color)) {
2072 ShowColors = Colors_Off;
2073 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2074 StringRef
Value(A->getValue());
2075 if (
Value ==
"always")
2076 ShowColors = Colors_On;
2077 else if (
Value ==
"never")
2078 ShowColors = Colors_Off;
2079 else if (
Value ==
"auto")
2080 ShowColors = Colors_Auto;
2083 return ShowColors == Colors_On ||
2084 (ShowColors == Colors_Auto &&
2085 llvm::sys::Process::StandardErrHasColors());
2090 bool Success =
true;
2091 for (
const auto &Prefix : VerifyPrefixes) {
2094 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2097 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2099 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2100 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2111 #define FILE_SYSTEM_OPTION_WITH_MARSHALLING( \
2112 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2113 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2114 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2115 MERGER, EXTRACTOR, TABLE_INDEX) \
2116 GENERATE_OPTION_WITH_MARSHALLING( \
2117 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2118 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2119 #include "clang/Driver/Options.inc"
2120 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2126 bool Success =
true;
2128 #define FILE_SYSTEM_OPTION_WITH_MARSHALLING( \
2129 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2130 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2131 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2132 MERGER, EXTRACTOR, TABLE_INDEX) \
2133 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
2134 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2135 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
2136 MERGER, TABLE_INDEX)
2137 #include "clang/Driver/Options.inc"
2138 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2148 #define MIGRATOR_OPTION_WITH_MARSHALLING( \
2149 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2150 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2151 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2152 MERGER, EXTRACTOR, TABLE_INDEX) \
2153 GENERATE_OPTION_WITH_MARSHALLING( \
2154 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2155 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2156 #include "clang/Driver/Options.inc"
2157 #undef MIGRATOR_OPTION_WITH_MARSHALLING
2163 bool Success =
true;
2165 #define MIGRATOR_OPTION_WITH_MARSHALLING( \
2166 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2167 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2168 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2169 MERGER, EXTRACTOR, TABLE_INDEX) \
2170 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
2171 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2172 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
2173 MERGER, TABLE_INDEX)
2174 #include "clang/Driver/Options.inc"
2175 #undef MIGRATOR_OPTION_WITH_MARSHALLING
2180 void CompilerInvocation::GenerateDiagnosticArgs(
2182 StringAllocator SA,
bool DefaultDiagColor) {
2184 #define DIAG_OPTION_WITH_MARSHALLING( \
2185 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2186 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2187 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2188 MERGER, EXTRACTOR, TABLE_INDEX) \
2189 GENERATE_OPTION_WITH_MARSHALLING( \
2190 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2191 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2192 #include "clang/Driver/Options.inc"
2193 #undef DIAG_OPTION_WITH_MARSHALLING
2199 if (Opts.ShowColors)
2202 if (Opts.VerifyDiagnostics &&
2207 if (Prefix !=
"expected")
2214 GenerateArg(Args, OPT_verify_ignore_unexpected, SA);
2217 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"note", SA);
2219 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"remark", SA);
2221 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"warning", SA);
2223 GenerateArg(Args, OPT_verify_ignore_unexpected_EQ,
"error", SA);
2226 for (
const auto &Warning : Opts.
Warnings) {
2228 if (Warning ==
"undef-prefix")
2230 Args.push_back(SA(StringRef(
"-W") + Warning));
2233 for (
const auto &Remark : Opts.
Remarks) {
2236 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2237 "pass-analysis",
"no-pass-analysis",
2238 "pass-missed",
"no-pass-missed"};
2239 if (llvm::is_contained(IgnoredRemarks, Remark))
2242 Args.push_back(SA(StringRef(
"-R") + Remark));
2248 bool DefaultDiagColor) {
2253 Diags = &*IgnoringDiags;
2261 #define DIAG_OPTION_WITH_MARSHALLING( \
2262 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2263 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2264 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2265 MERGER, EXTRACTOR, TABLE_INDEX) \
2266 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, Success, ID, FLAGS, PARAM, \
2267 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2268 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
2269 MERGER, TABLE_INDEX)
2270 #include "clang/Driver/Options.inc"
2271 #undef DIAG_OPTION_WITH_MARSHALLING
2273 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2276 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2280 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2282 if (Args.hasArg(OPT_verify))
2287 Opts.VerifyDiagnostics =
false;
2294 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
2296 if (Args.hasArg(OPT_verify_ignore_unexpected))
2298 Opts.setVerifyIgnoreUnexpected(DiagMask);
2301 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2317 unsigned &MajorVersion,
2318 unsigned &MinorVersion,
2321 SmallVector<StringRef, 5> Args;
2322 Arg.split(Args,
':', 5);
2323 if (Args.size() < 5)
2327 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2328 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2329 if (Args[3].getAsInteger(2, Hashed))
return true;
2330 if (Args.size() > 4)
2340 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2386 OPT_print_dependency_directives_minimized_source},
2395 if (ActionOpt.second == Opt.getID())
2396 return ActionOpt.first;
2405 if (ActionOpt.first == ProgramAction)
2406 return OptSpecifier(ActionOpt.second);
2416 #define FRONTEND_OPTION_WITH_MARSHALLING( \
2417 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2418 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2419 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2420 MERGER, EXTRACTOR, TABLE_INDEX) \
2421 GENERATE_OPTION_WITH_MARSHALLING( \
2422 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2423 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2424 #include "clang/Driver/Options.inc"
2425 #undef FRONTEND_OPTION_WITH_MARSHALLING
2431 std::function<void()> GenerateProgramAction = [&]() {
2435 if (!ProgramActionOpt) {
2438 "Frontend action without option.");
2439 GenerateProgramAction = [&]() {
2446 GenerateProgramAction = [&]() {
2454 llvm_unreachable(
"Default AST dump format.");
2461 GenerateArg(Args, OPT_ast_dump_all_EQ, Format, SA);
2474 GenerateProgramAction = [&]() {
2479 GenerateProgramAction();
2481 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2483 const char *Spelling =
2484 SA(Opt.getPrefix() + Opt.getName() + PluginArgs.first);
2485 for (
const auto &PluginArg : PluginArgs.second)
2490 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2491 GenerateArg(Args, OPT_ftest_module_file_extension_EQ, TestExt->str(), SA);
2497 for (
const auto &Plugin : Opts.
Plugins)
2503 GenerateArg(Args, OPT_fmodule_file, ModuleFile, SA);
2510 GenerateArg(Args, OPT_aux_target_feature, Feature, SA);
2516 StringRef Header = IsHeader ?
"-header" :
"";
2539 Lang =
"objective-c";
2542 Lang =
"objective-c++";
2545 Lang =
"renderscript";
2548 Lang =
"assembler-with-cpp";
2552 "Generating -x argument for unknown language (not precompiled).");
2564 for (
const auto &Input : Opts.
Inputs)
2565 Args.push_back(SA(Input.getFile()));
2571 bool Success =
true;
2573 #define FRONTEND_OPTION_WITH_MARSHALLING( \
2574 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2575 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2576 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2577 MERGER, EXTRACTOR, TABLE_INDEX) \
2578 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
2579 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2580 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
2581 MERGER, TABLE_INDEX)
2582 #include "clang/Driver/Options.inc"
2583 #undef FRONTEND_OPTION_WITH_MARSHALLING
2586 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2587 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2589 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2592 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2593 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2601 Diags.
Report(diag::err_drv_invalid_value)
2602 << A->getAsString(Args) << A->getValue();
2612 Args.hasArg(OPT_interface_stub_version_EQ)
2613 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2614 :
"experimental-ifs-v2";
2615 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2616 ArgStr ==
"experimental-ifs-v1" ||
2617 ArgStr ==
"experimental-tapi-elf-v1") {
2619 "Invalid interface stub format: " + ArgStr.str() +
2621 Diags.
Report(diag::err_drv_invalid_value)
2622 <<
"Must specify a valid interface stub format type, ie: "
2623 "-interface-stub-version=experimental-ifs-v2"
2626 }
else if (!ArgStr.startswith(
"experimental-ifs-")) {
2628 "Invalid interface stub format: " + ArgStr.str() +
".";
2629 Diags.
Report(diag::err_drv_invalid_value)
2630 <<
"Must specify a valid interface stub format type, ie: "
2631 "-interface-stub-version=experimental-ifs-v2"
2640 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2641 Opts.
Plugins.emplace_back(A->getValue(0));
2645 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2646 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2649 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2651 unsigned MajorVersion;
2652 unsigned MinorVersion;
2656 MinorVersion, Hashed, UserInfo)) {
2657 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2664 std::make_shared<TestModuleFileExtension>(
2665 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2668 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2672 Diags.
Report(diag::err_drv_invalid_value)
2673 << A->getAsString(Args) << A->getValue();
2676 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2677 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2678 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2680 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2681 StringRef Val = A->getValue();
2682 if (Val.find(
'=') == StringRef::npos)
2687 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2690 if (Args.hasArg(OPT_aux_target_cpu))
2692 if (Args.hasArg(OPT_aux_target_feature))
2697 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2698 <<
"ARC migration" <<
"ObjC migration";
2702 if (
const Arg *A = Args.getLastArg(OPT_x)) {
2703 StringRef XValue = A->getValue();
2707 bool Preprocessed = XValue.consume_back(
"-cpp-output");
2708 bool ModuleMap = XValue.consume_back(
"-module-map");
2710 XValue !=
"precompiled-header" &&
2711 XValue.consume_back(
"-header");
2714 DashX = llvm::StringSwitch<InputKind>(XValue)
2729 DashX = llvm::StringSwitch<InputKind>(XValue)
2736 DashX = llvm::StringSwitch<InputKind>(XValue)
2739 .Cases(
"ast",
"pcm",
"precompiled-header",
2745 Diags.
Report(diag::err_drv_invalid_value)
2746 << A->getAsString(Args) << A->getValue();
2755 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
2758 Inputs.push_back(
"-");
2759 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
2763 StringRef(Inputs[i]).rsplit(
'.').second);
2772 bool IsSystem =
false;
2781 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
2792 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
2793 return Driver::GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
2800 #define HEADER_SEARCH_OPTION_WITH_MARSHALLING( \
2801 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2802 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2803 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2804 MERGER, EXTRACTOR, TABLE_INDEX) \
2805 GENERATE_OPTION_WITH_MARSHALLING( \
2806 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
2807 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2808 #include "clang/Driver/Options.inc"
2809 #undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
2821 GenerateArg(Args, OPT_fprebuilt_module_path, Path, SA);
2824 GenerateArg(Args, OPT_fmodules_ignore_macro, Macro.val(), SA);
2830 return llvm::find(Groups, Entry.
Group) != Groups.end() &&
2831 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
2832 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
2842 OptSpecifier Opt = [It, Matches]() {
2851 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
2867 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
2879 GenerateArg(Args, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
2884 GenerateArg(Args, OPT_iframeworkwithsysroot, It->Path, SA);
2892 GenerateArg(Args, OPT_objc_isystem, It->Path, SA);
2894 GenerateArg(Args, OPT_objcxx_isystem, It->Path, SA);
2904 ? OPT_internal_isystem
2905 : OPT_internal_externc_isystem;
2909 assert(It ==
End &&
"Unhandled HeaderSearchOption::Entry.");
2913 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
2914 : OPT_no_system_header_prefix;
2926 bool Success =
true;
2928 #define HEADER_SEARCH_OPTION_WITH_MARSHALLING( \
2929 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
2930 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
2931 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
2932 MERGER, EXTRACTOR, TABLE_INDEX) \
2933 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
2934 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
2935 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
2936 MERGER, TABLE_INDEX)
2937 #include "clang/Driver/Options.inc"
2938 #undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
2940 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
2941 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
2945 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
2946 if (WorkingDir.empty())
2947 llvm::sys::fs::make_absolute(
P);
2949 llvm::sys::fs::make_absolute(WorkingDir,
P);
2951 llvm::sys::path::remove_dots(
P);
2955 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2956 StringRef Val = A->getValue();
2957 if (Val.find(
'=') != StringRef::npos){
2958 auto Split = Val.split(
'=');
2963 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
2966 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
2967 StringRef MacroDef = A->getValue();
2969 llvm::CachedHashString(MacroDef.split(
'=').first));
2973 bool IsIndexHeaderMap =
false;
2974 bool IsSysrootSpecified =
2975 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
2976 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
2977 if (A->getOption().matches(OPT_index_header_map)) {
2979 IsIndexHeaderMap =
true;
2986 bool IsFramework = A->getOption().matches(OPT_F);
2989 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
2991 llvm::sys::path::append(Buffer, Opts.
Sysroot,
2992 llvm::StringRef(A->getValue()).substr(1));
2996 Opts.
AddPath(Path, Group, IsFramework,
2998 IsIndexHeaderMap =
false;
3002 StringRef Prefix =
"";
3003 for (
const auto *A :
3004 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3005 if (A->getOption().matches(OPT_iprefix))
3006 Prefix = A->getValue();
3007 else if (A->getOption().matches(OPT_iwithprefix))
3013 for (
const auto *A : Args.filtered(OPT_idirafter))
3015 for (
const auto *A : Args.filtered(OPT_iquote))
3017 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
3019 !A->getOption().matches(OPT_iwithsysroot));
3020 for (
const auto *A : Args.filtered(OPT_iframework))
3022 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3027 for (
const auto *A : Args.filtered(OPT_c_isystem))
3029 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3031 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3033 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3037 for (
const auto *A :
3038 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3040 if (A->getOption().matches(OPT_internal_externc_isystem))
3042 Opts.
AddPath(A->getValue(), Group,
false,
true);
3046 for (
const auto *A :
3047 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3049 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3051 for (
const auto *A : Args.filtered(OPT_ivfsoverlay))
3058 const llvm::Triple &T,
3059 std::vector<std::string> &Includes,
3069 Opts.AsmPreprocessor = 1;
3079 llvm_unreachable(
"Invalid input kind!");
3081 LangStd = LangStandard::lang_opencl10;
3084 LangStd = LangStandard::lang_openclcpp;
3087 LangStd = LangStandard::lang_cuda;
3091 #if defined(CLANG_DEFAULT_STD_C)
3092 LangStd = CLANG_DEFAULT_STD_C;
3096 LangStd = LangStandard::lang_gnu99;
3098 LangStd = LangStandard::lang_gnu17;
3102 #if defined(CLANG_DEFAULT_STD_C)
3103 LangStd = CLANG_DEFAULT_STD_C;
3105 LangStd = LangStandard::lang_gnu11;
3110 #if defined(CLANG_DEFAULT_STD_CXX)
3111 LangStd = CLANG_DEFAULT_STD_CXX;
3113 LangStd = LangStandard::lang_gnucxx14;
3117 LangStd = LangStandard::lang_c99;
3120 LangStd = LangStandard::lang_hip;
3127 Opts.LineComment =
Std.hasLineComments();
3128 Opts.C99 =
Std.isC99();
3129 Opts.C11 =
Std.isC11();
3130 Opts.C17 =
Std.isC17();
3131 Opts.C2x =
Std.isC2x();
3132 Opts.CPlusPlus =
Std.isCPlusPlus();
3133 Opts.CPlusPlus11 =
Std.isCPlusPlus11();
3134 Opts.CPlusPlus14 =
Std.isCPlusPlus14();
3135 Opts.CPlusPlus17 =
Std.isCPlusPlus17();
3136 Opts.CPlusPlus20 =
Std.isCPlusPlus20();
3137 Opts.CPlusPlus2b =
Std.isCPlusPlus2b();
3138 Opts.GNUMode =
Std.isGNUMode();
3139 Opts.GNUCVersion = 0;
3140 Opts.HexFloats =
Std.hasHexFloats();
3141 Opts.ImplicitInt =
Std.hasImplicitInt();
3143 Opts.CPlusPlusModules = Opts.CPlusPlus20;
3146 Opts.OpenCL =
Std.isOpenCL();
3147 if (LangStd == LangStandard::lang_opencl10)
3148 Opts.OpenCLVersion = 100;
3149 else if (LangStd == LangStandard::lang_opencl11)
3150 Opts.OpenCLVersion = 110;
3151 else if (LangStd == LangStandard::lang_opencl12)
3152 Opts.OpenCLVersion = 120;
3153 else if (LangStd == LangStandard::lang_opencl20)
3154 Opts.OpenCLVersion = 200;
3155 else if (LangStd == LangStandard::lang_opencl30)
3156 Opts.OpenCLVersion = 300;
3157 else if (LangStd == LangStandard::lang_openclcpp)
3158 Opts.OpenCLCPlusPlusVersion = 100;
3165 Opts.OpenCLCPlusPlus = Opts.CPlusPlus;
3166 Opts.OpenCLPipe = Opts.OpenCLCPlusPlus || Opts.OpenCLVersion == 200;
3167 Opts.OpenCLGenericAddressSpace =
3168 Opts.OpenCLCPlusPlus || Opts.OpenCLVersion == 200;
3171 if (Opts.IncludeDefaultHeader) {
3172 if (Opts.DeclareOpenCLBuiltins) {
3174 Includes.push_back(
"opencl-c-base.h");
3176 Includes.push_back(
"opencl-c.h");
3193 }
else if (Opts.CUDA) {
3201 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
3204 Opts.Half = Opts.OpenCL;
3213 llvm_unreachable(
"should not parse language flags for this input");
3246 llvm_unreachable(
"unexpected input language");
3255 return "Objective-C";
3259 return "Objective-C++";
3263 return "C++ for OpenCL";
3267 return "RenderScript";
3279 llvm_unreachable(
"unknown input language");
3282 void CompilerInvocation::GenerateLangArgs(
const LangOptions &Opts,
3285 const llvm::Triple &T) {
3286 OptSpecifier StdOpt;
3288 case LangStandard::lang_opencl10:
3289 case LangStandard::lang_opencl11:
3290 case LangStandard::lang_opencl12:
3291 case LangStandard::lang_opencl20:
3292 case LangStandard::lang_opencl30:
3293 case LangStandard::lang_openclcpp:
3294 StdOpt = OPT_cl_std_EQ;
3297 StdOpt = OPT_std_EQ;
3304 if (Opts.IncludeDefaultHeader)
3305 GenerateArg(Args, OPT_finclude_default_header, SA);
3306 if (Opts.DeclareOpenCLBuiltins)
3307 GenerateArg(Args, OPT_fdeclare_opencl_builtins, SA);
3311 #define LANG_OPTION_WITH_MARSHALLING( \
3312 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
3313 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
3314 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
3315 MERGER, EXTRACTOR, TABLE_INDEX) \
3316 GENERATE_OPTION_WITH_MARSHALLING( \
3317 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
3318 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
3319 #include "clang/Driver/Options.inc"
3320 #undef LANG_OPTION_WITH_MARSHALLING
3331 else if (Opts.ObjCAutoRefCount == 1)
3334 if (Opts.ObjCWeakRuntime)
3335 GenerateArg(Args, OPT_fobjc_runtime_has_weak, SA);
3340 if (Opts.ObjCSubscriptingLegacyRuntime)
3341 GenerateArg(Args, OPT_fobjc_subscripting_legacy_runtime, SA);
3344 if (Opts.GNUCVersion != 0) {
3345 unsigned Major = Opts.GNUCVersion / 100 / 100;
3346 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3347 unsigned Patch = Opts.GNUCVersion % 100;
3349 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch), SA);
3352 if (Opts.IgnoreXCOFFVisibility)
3353 GenerateArg(Args, OPT_mignore_xcoff_visibility, SA);
3362 if (Opts.MSCompatibilityVersion != 0) {
3363 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3364 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3365 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3367 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor), SA);
3370 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS()) {
3371 if (!Opts.Trigraphs)
3378 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3381 if (Opts.ConvergentFunctions &&
3382 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice))
3385 if (Opts.NoBuiltin && !Opts.Freestanding)
3388 if (!Opts.NoBuiltin)
3392 if (Opts.LongDoubleSize == 128)
3394 else if (Opts.LongDoubleSize == 64)
3401 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3404 if (Opts.OpenMP != 50)
3405 GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3407 if (!Opts.OpenMPUseTLS)
3410 if (Opts.OpenMPIsDevice)
3413 if (Opts.OpenMPIRBuilder)
3414 GenerateArg(Args, OPT_fopenmp_enable_irbuilder, SA);
3417 if (Opts.OpenMPSimd) {
3420 if (Opts.OpenMP != 50)
3421 GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3424 if (Opts.OpenMPCUDANumSMs != 0)
3425 GenerateArg(Args, OPT_fopenmp_cuda_number_of_sm_EQ,
3426 Twine(Opts.OpenMPCUDANumSMs), SA);
3428 if (Opts.OpenMPCUDABlocksPerSM != 0)
3429 GenerateArg(Args, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3430 Twine(Opts.OpenMPCUDABlocksPerSM), SA);
3432 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3433 GenerateArg(Args, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3434 Twine(Opts.OpenMPCUDAReductionBufNum), SA);
3438 llvm::raw_string_ostream
OS(Targets);
3441 [&OS](
const llvm::Triple &T) { OS << T.str(); },
",");
3448 if (Opts.OpenMPCUDAMode)
3451 if (Opts.OpenMPCUDATargetParallel)
3452 GenerateArg(Args, OPT_fopenmp_cuda_parallel_target_regions, SA);
3454 if (Opts.OpenMPCUDAForceFullRuntime)
3455 GenerateArg(Args, OPT_fopenmp_cuda_force_full_runtime, SA);
3467 GenerateArg(Args, OPT_ffp_contract,
"fast-honor-pragmas", SA);
3470 GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
3474 GenerateArg(Args, OPT_fsanitize_blacklist, F, SA);
3477 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"3.8", SA);
3479 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"4.0", SA);
3481 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"6.0", SA);
3483 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"7.0", SA);
3485 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"9.0", SA);
3487 GenerateArg(Args, OPT_fclang_abi_compat_EQ,
"11.0", SA);
3489 if (Opts.getSignReturnAddressScope() ==
3491 GenerateArg(Args, OPT_msign_return_address_EQ,
"all", SA);
3492 else if (Opts.getSignReturnAddressScope() ==
3494 GenerateArg(Args, OPT_msign_return_address_EQ,
"non-leaf", SA);
3496 if (Opts.getSignReturnAddressKey() ==
3498 GenerateArg(Args, OPT_msign_return_address_key_EQ,
"b_key", SA);
3501 bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3503 std::vector<std::string> &Includes,
3509 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3512 Diags.
Report(diag::err_drv_invalid_value)
3513 << A->getAsString(Args) << A->getValue();
3515 for (
unsigned KindValue = 0;
3521 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3522 Diag <<
Std.getName() <<
Std.getDescription();
3523 unsigned NumAliases = 0;
3524 #define LANGSTANDARD(id, name, lang, desc, features)
3525 #define LANGSTANDARD_ALIAS(id, alias) \
3526 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3527 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
3528 #include "clang/Basic/LangStandards.def"
3530 #define LANGSTANDARD(id, name, lang, desc, features)
3531 #define LANGSTANDARD_ALIAS(id, alias) \
3532 if (KindValue == LangStandard::lang_##id) Diag << alias;
3533 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
3534 #include "clang/Basic/LangStandards.def"
3542 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3550 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3552 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3553 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3554 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3555 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3556 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3557 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3558 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3559 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp)
3563 Diags.
Report(diag::err_drv_invalid_value)
3564 << A->getAsString(Args) << A->getValue();
3567 LangStd = OpenCLLangStd;
3571 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3572 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3581 #define LANG_OPTION_WITH_MARSHALLING( \
3582 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
3583 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
3584 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
3585 MERGER, EXTRACTOR, TABLE_INDEX) \
3586 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
3587 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
3588 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
3589 MERGER, TABLE_INDEX)
3590 #include "clang/Driver/Options.inc"
3591 #undef LANG_OPTION_WITH_MARSHALLING
3593 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3594 StringRef Name = A->getValue();
3595 if (Name ==
"full" || Name ==
"branch") {
3596 Opts.CFProtectionBranch = 1;
3601 if (Arg *
arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3602 StringRef value =
arg->getValue();
3604 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3607 if (Args.hasArg(OPT_fobjc_gc_only))
3609 else if (Args.hasArg(OPT_fobjc_gc))
3611 else if (Args.hasArg(OPT_fobjc_arc)) {
3612 Opts.ObjCAutoRefCount = 1;
3614 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3621 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3622 Opts.ObjCWeakRuntime = 1;
3628 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3629 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3630 assert(!Opts.ObjCWeak);
3632 Diags.
Report(diag::err_objc_weak_with_gc);
3633 }
else if (!Opts.ObjCWeakRuntime) {
3634 Diags.
Report(diag::err_objc_weak_unsupported);
3638 }
else if (Opts.ObjCAutoRefCount) {
3639 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3642 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3643 Opts.ObjCSubscriptingLegacyRuntime =
3647 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
3650 VersionTuple GNUCVer;
3651 bool Invalid = GNUCVer.tryParse(A->getValue());
3652 unsigned Major = GNUCVer.getMajor();
3653 unsigned Minor = GNUCVer.getMinor().getValueOr(0);
3654 unsigned Patch = GNUCVer.getSubminor().getValueOr(0);
3655 if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
3656 Diags.
Report(diag::err_drv_invalid_value)
3657 << A->getAsString(Args) << A->getValue();
3659 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
3682 if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility) ||
3683 !Args.hasArg(OPT_fvisibility)))
3684 Opts.IgnoreXCOFFVisibility = 1;
3686 if (Args.hasArg(OPT_ftrapv)) {
3690 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
3692 else if (Args.hasArg(OPT_fwrapv))
3695 Opts.MSCompatibilityVersion = 0;
3696 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
3698 if (VT.tryParse(A->getValue()))
3699 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3701 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
3702 VT.getMinor().getValueOr(0) * 100000 +
3703 VT.getSubminor().getValueOr(0);
3711 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS();
3713 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
3715 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
3716 && Opts.OpenCLVersion == 200);
3718 Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
3719 Opts.SYCLIsDevice ||
3720 Args.hasArg(OPT_fconvergent_functions);
3722 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
3723 if (!Opts.NoBuiltin)
3725 Opts.LongDoubleSize = Args.hasArg(OPT_mlong_double_128)
3727 : Args.hasArg(OPT_mlong_double_64) ? 64 : 0;
3728 if (Opts.FastRelaxedMath)
3733 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3735 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3736 << A->getSpelling() <<
"-fdefault-calling-conv";
3738 if (T.getArch() != llvm::Triple::x86)
3739 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3740 << A->getSpelling() << T.getTriple();
3747 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 50 : 0;
3749 bool IsSimdSpecified =
3750 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
3752 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
3754 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
3755 Opts.OpenMPIsDevice =
3756 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
3757 Opts.OpenMPIRBuilder =
3758 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
3759 bool IsTargetSpecified =
3760 Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
3762 Opts.ConvergentFunctions = Opts.ConvergentFunctions || Opts.OpenMPIsDevice;
3764 if (Opts.OpenMP || Opts.OpenMPSimd) {
3766 Args, OPT_fopenmp_version_EQ,
3767 (IsSimdSpecified || IsTargetSpecified) ? 50 : Opts.OpenMP, Diags))
3768 Opts.OpenMP = Version;
3771 if (!Opts.OpenMPIsDevice) {
3772 switch (T.getArch()) {
3776 case llvm::Triple::nvptx:
3777 case llvm::Triple::nvptx64:
3778 Diags.
Report(diag::err_drv_omp_host_target_not_supported) << T.str();
3786 if ((Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN())) ||
3787 Opts.OpenCLCPlusPlus) {
3788 Opts.Exceptions = 0;
3789 Opts.CXXExceptions = 0;
3791 if (Opts.OpenMPIsDevice && T.isNVPTX()) {
3792 Opts.OpenMPCUDANumSMs =
3794 Opts.OpenMPCUDANumSMs, Diags);
3795 Opts.OpenMPCUDABlocksPerSM =
3797 Opts.OpenMPCUDABlocksPerSM, Diags);
3799 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3800 Opts.OpenMPCUDAReductionBufNum, Diags);
3804 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
3805 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
3806 auto getArchPtrSize = [](
const llvm::Triple &T) {
3807 if (T.isArch16Bit())
3809 if (T.isArch32Bit())
3811 assert(T.isArch64Bit() &&
"Expected 64-bit architecture");
3815 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
3816 llvm::Triple TT(A->getValue(i));
3818 if (TT.getArch() == llvm::Triple::UnknownArch ||
3819 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
3820 TT.getArch() == llvm::Triple::nvptx ||
3821 TT.getArch() == llvm::Triple::nvptx64 ||
3822 TT.getArch() == llvm::Triple::amdgcn ||
3823 TT.getArch() == llvm::Triple::x86 ||
3824 TT.getArch() == llvm::Triple::x86_64))
3825 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
3826 else if (getArchPtrSize(T) != getArchPtrSize(TT))
3827 Diags.
Report(diag::err_drv_incompatible_omp_arch)
3828 << A->getValue(i) << T.str();
3836 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
3839 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
3844 Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) &&
3845 Args.hasArg(options::OPT_fopenmp_cuda_mode);
3849 Opts.OpenMPCUDATargetParallel =
3850 Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) &&
3851 Args.hasArg(options::OPT_fopenmp_cuda_parallel_target_regions);
3854 Opts.OpenMPCUDAForceFullRuntime =
3855 Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) &&
3856 Args.hasArg(options::OPT_fopenmp_cuda_force_full_runtime);
3861 Opts.Optimize = Opt != 0;
3862 Opts.OptimizeSize = OptSize != 0;
3867 Opts.NoInlineDefine = !Opts.Optimize;
3868 if (Arg *InlineArg = Args.getLastArg(
3869 options::OPT_finline_functions, options::OPT_finline_hint_functions,
3870 options::OPT_fno_inline_functions, options::OPT_fno_inline))
3871 if (InlineArg->getOption().matches(options::OPT_fno_inline))
3872 Opts.NoInlineDefine =
true;
3874 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
3875 StringRef Val = A->getValue();
3878 else if (Val ==
"on")
3880 else if (Val ==
"off")
3882 else if (Val ==
"fast-honor-pragmas")
3885 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
3892 std::vector<std::string> systemBlacklists =
3893 Args.getAllArgValues(OPT_fsanitize_system_blacklist);
3895 systemBlacklists.begin(), systemBlacklists.end());
3897 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
3900 StringRef Ver = A->getValue();
3901 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
3902 unsigned Major, Minor = 0;
3906 if (!VerParts.first.startswith(
"0") &&
3907 !VerParts.first.getAsInteger(10, Major) &&
3908 3 <= Major && Major <= CLANG_VERSION_MAJOR &&
3909 (Major == 3 ? VerParts.second.size() == 1 &&
3910 !VerParts.second.getAsInteger(10, Minor)
3911 : VerParts.first.size() == Ver.size() ||
3912 VerParts.second ==
"0")) {
3914 if (Major == 3 && Minor <= 8)
3916 else if (Major <= 4)
3918 else if (Major <= 6)
3920 else if (Major <= 7)
3922 else if (Major <= 9)
3924 else if (Major <= 11)
3926 }
else if (Ver !=
"latest") {
3927 Diags.
Report(diag::err_drv_invalid_value)
3928 << A->getAsString(Args) << A->getValue();
3932 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
3933 StringRef SignScope = A->getValue();
3935 if (SignScope.equals_lower(
"none"))
3936 Opts.setSignReturnAddressScope(
3938 else if (SignScope.equals_lower(
"all"))
3939 Opts.setSignReturnAddressScope(
3941 else if (SignScope.equals_lower(
"non-leaf"))
3942 Opts.setSignReturnAddressScope(
3945 Diags.
Report(diag::err_drv_invalid_value)
3946 << A->getAsString(Args) << SignScope;
3948 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
3949 StringRef SignKey = A->getValue();
3950 if (!SignScope.empty() && !SignKey.empty()) {
3951 if (SignKey.equals_lower(
"a_key"))
3952 Opts.setSignReturnAddressKey(
3954 else if (SignKey.equals_lower(
"b_key"))
3955 Opts.setSignReturnAddressKey(
3958 Diags.
Report(diag::err_drv_invalid_value)
3959 << A->getAsString(Args) << SignKey;
4008 llvm_unreachable(
"invalid frontend action");
4019 #define PREPROCESSOR_OPTION_WITH_MARSHALLING( \
4020 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4021 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4022 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4023 MERGER, EXTRACTOR, TABLE_INDEX) \
4024 GENERATE_OPTION_WITH_MARSHALLING( \
4025 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
4026 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4027 #include "clang/Driver/Options.inc"
4028 #undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4031 GenerateArg(Args, OPT_pch_through_hdrstop_use, SA);
4034 GenerateArg(Args, OPT_error_on_deserialized_pch_decl, D, SA);
4037 GenerateArg(Args, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second, SA);
4045 for (
const auto &M : Opts.
Macros) {
4048 if (M.first ==
"__CET__=1" && !M.second &&
4049 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4051 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4052 !CodeGenOpts.CFProtectionBranch)
4054 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4055 CodeGenOpts.CFProtectionBranch)
4058 GenerateArg(Args, M.second ? OPT_U : OPT_D, M.first, SA);
4061 for (
const auto &I : Opts.
Includes) {
4064 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4065 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4076 GenerateArg(Args, OPT_remap_file, RF.first +
";" + RF.second, SA);
4087 bool Success =
true;
4089 #define PREPROCESSOR_OPTION_WITH_MARSHALLING( \
4090 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4091 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4092 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4093 MERGER, EXTRACTOR, TABLE_INDEX) \
4094 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
4095 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
4096 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
4097 MERGER, TABLE_INDEX)
4098 #include "clang/Driver/Options.inc"
4099 #undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4101 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4102 Args.hasArg(OPT_pch_through_hdrstop_use);
4104 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4107 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4108 auto Split = StringRef(A).split(
'=');
4113 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4114 StringRef
Value(A->getValue());
4115 size_t Comma =
Value.find(
',');
4117 unsigned EndOfLine = 0;
4119 if (Comma == StringRef::npos ||
4120 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4121 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4122 Diags.
Report(diag::err_drv_preamble_format);
4130 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4131 StringRef Name = A->getValue();
4132 if (Name ==
"branch")
4134 else if (Name ==
"return")
4136 else if (Name ==
"full")
4141 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4142 if (A->getOption().matches(OPT_D))
4149 for (
const auto *A : Args.filtered(OPT_include))
4150 Opts.
Includes.emplace_back(A->getValue());
4152 for (
const auto *A : Args.filtered(OPT_chain_include))
4155 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4156 std::pair<StringRef, StringRef>
Split = StringRef(A->getValue()).split(
';');
4158 if (
Split.second.empty()) {
4159 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4180 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING( \
4181 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4182 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4183 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4184 MERGER, EXTRACTOR, TABLE_INDEX) \
4185 GENERATE_OPTION_WITH_MARSHALLING( \
4186 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
4187 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4188 #include "clang/Driver/Options.inc"
4189 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4203 bool Success =
true;
4205 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING( \
4206 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4207 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4208 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4209 MERGER, EXTRACTOR, TABLE_INDEX) \
4210 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
4211 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
4212 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
4213 MERGER, TABLE_INDEX)
4214 #include "clang/Driver/Options.inc"
4215 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4218 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4220 return Success && Diags.
getNumErrors() == NumErrorsBefore;
4227 #define TARGET_OPTION_WITH_MARSHALLING( \
4228 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4229 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4230 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4231 MERGER, EXTRACTOR, TABLE_INDEX) \
4232 GENERATE_OPTION_WITH_MARSHALLING( \
4233 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
4234 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4235 #include "clang/Driver/Options.inc"
4236 #undef TARGET_OPTION_WITH_MARSHALLING
4247 bool Success =
true;
4249 #define TARGET_OPTION_WITH_MARSHALLING( \
4250 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
4251 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
4252 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
4253 MERGER, EXTRACTOR, TABLE_INDEX) \
4254 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \
4255 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \
4256 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
4257 MERGER, TABLE_INDEX)
4258 #include "clang/Driver/Options.inc"
4259 #undef TARGET_OPTION_WITH_MARSHALLING
4261 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4262 llvm::VersionTuple Version;
4263 if (Version.tryParse(A->getValue()))
4264 Diags.
Report(diag::err_drv_invalid_value)
4265 << A->getAsString(Args) << A->getValue();
4270 return Success && Diags.
getNumErrors() == NumErrorsBefore;
4273 bool CompilerInvocation::CreateFromArgsImpl(
4281 unsigned MissingArgIndex, MissingArgCount;
4282 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4283 MissingArgCount, IncludedFlagsBitmask);
4287 if (MissingArgCount) {
4288 Diags.
Report(diag::err_drv_missing_argument)
4289 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4294 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4295 auto ArgString = A->getAsString(Args);
4297 if (Opts.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
4298 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4300 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4301 << ArgString << Nearest;
4323 if (Args.hasArg(OPT_fobjc_arc))
4328 LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
4358 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4359 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4360 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4361 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4374 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4382 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4397 const char *Argv0) {
4403 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4407 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4413 using llvm::hash_code;
4416 using llvm::hash_combine_range;
4429 #define LANGOPT(Name, Bits, Default, Description) \
4430 code = hash_combine(code, LangOpts->Name);
4431 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4432 code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
4433 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
4434 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4435 #include "clang/Basic/LangOptions.def"
4437 for (StringRef Feature :
LangOpts->ModuleFeatures)
4441 const auto &BCN =
LangOpts->CommentOpts.BlockCommandNames;
4442 code =
hash_combine(code, hash_combine_range(BCN.begin(), BCN.end()));
4447 for (
const auto &FeatureAsWritten :
TargetOpts->FeaturesAsWritten)
4460 StringRef MacroDef = I.first;
4462 llvm::CachedHashString(MacroDef.split(
'=').first)))
4483 hash_code UEC = hash_combine_range(hsOpts.
UserEntries.begin(),
4489 #define DIAGOPT(Name, Bits, Default) \
4490 code = hash_combine(code, diagOpts.Name);
4491 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4492 code = hash_combine(code, diagOpts.get##Name());
4493 #include "clang/Basic/DiagnosticOptions.def"
4504 code = ext->hashExtension(code);
4511 code =
hash_combine(code, KeyValue.first, KeyValue.second);
4517 if (!SanHash.
empty())
4545 GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
4549 GenerateLangArgs(*
LangOpts, Args, SA, T);
4552 GenerateCodeGenArgs(CodeGenOpts, Args, SA, T, FrontendOpts.
OutputFile,
4565 llvm::vfs::getRealFileSystem());
4578 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
4579 Result->getBufferForFile(
File);
4581 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
4586 std::move(Buffer.get()),
nullptr,
File,
4589 Diags.
Report(diag::err_invalid_vfs_overlay) <<
File;