29#include "clang/Config/config.h"
48#include "llvm/ADT/APInt.h"
49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/CachedHashString.h"
51#include "llvm/ADT/FloatingPointMode.h"
52#include "llvm/ADT/Hashing.h"
53#include "llvm/ADT/STLExtras.h"
54#include "llvm/ADT/SmallString.h"
55#include "llvm/ADT/SmallVector.h"
56#include "llvm/ADT/StringRef.h"
57#include "llvm/ADT/StringSwitch.h"
58#include "llvm/ADT/Twine.h"
59#include "llvm/Config/llvm-config.h"
60#include "llvm/Frontend/Debug/Options.h"
61#include "llvm/IR/DebugInfoMetadata.h"
62#include "llvm/Linker/Linker.h"
63#include "llvm/MC/MCTargetOptions.h"
64#include "llvm/Option/Arg.h"
65#include "llvm/Option/ArgList.h"
66#include "llvm/Option/OptSpecifier.h"
67#include "llvm/Option/OptTable.h"
68#include "llvm/Option/Option.h"
69#include "llvm/ProfileData/InstrProfReader.h"
70#include "llvm/Remarks/HotnessThresholdParser.h"
71#include "llvm/Support/CodeGen.h"
72#include "llvm/Support/Compiler.h"
73#include "llvm/Support/Error.h"
74#include "llvm/Support/ErrorHandling.h"
75#include "llvm/Support/ErrorOr.h"
76#include "llvm/Support/FileSystem.h"
77#include "llvm/Support/HashBuilder.h"
78#include "llvm/Support/MathExtras.h"
79#include "llvm/Support/MemoryBuffer.h"
80#include "llvm/Support/Path.h"
81#include "llvm/Support/Process.h"
82#include "llvm/Support/Regex.h"
83#include "llvm/Support/VersionTuple.h"
84#include "llvm/Support/VirtualFileSystem.h"
85#include "llvm/Support/raw_ostream.h"
86#include "llvm/Target/TargetOptions.h"
87#include "llvm/TargetParser/Host.h"
88#include "llvm/TargetParser/Triple.h"
101#include <type_traits>
105using namespace clang;
106using namespace driver;
107using namespace options;
118 if (Arg.getAsInteger(10, Val))
119 return llvm::createStringError(llvm::inconvertibleErrorCode(),
120 "Not an integer: %s", Arg.data());
129template <
class T> std::shared_ptr<T> make_shared_copy(
const T &
X) {
130 return std::make_shared<T>(
X);
135 return llvm::makeIntrusiveRefCnt<T>(
X);
157 LangOpts = make_shared_copy(
X.getLangOpts());
160 HSOpts = make_shared_copy(
X.getHeaderSearchOpts());
161 PPOpts = make_shared_copy(
X.getPreprocessorOpts());
166 FSOpts = make_shared_copy(
X.getFileSystemOpts());
207T &ensureOwned(std::shared_ptr<T> &Storage) {
208 if (Storage.use_count() > 1)
209 Storage = std::make_shared<T>(*Storage);
215 if (Storage.useCount() > 1)
216 Storage = llvm::makeIntrusiveRefCnt<T>(*Storage);
234 return ensureOwned(
HSOpts);
238 return ensureOwned(
PPOpts);
258 return ensureOwned(
FSOpts);
280#define SIMPLE_ENUM_VALUE_TABLE
281#include "clang/Driver/Options.inc"
282#undef SIMPLE_ENUM_VALUE_TABLE
288 if (Args.hasArg(Opt))
297 if (Args.hasArg(Opt))
307 const Twine &Spelling, Option::OptionClass,
313 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
317 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
319 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
321 if (Args.hasArg(Opt))
328 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
334 OptSpecifier OtherOpt) {
335 return [
Value, OtherValue,
336 OtherOpt](OptSpecifier Opt,
unsigned,
const ArgList &Args,
338 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
339 return A->getOption().matches(Opt) ?
Value : OtherValue;
347 Option::OptionClass,
unsigned,
bool KeyPath) {
348 if (KeyPath ==
Value)
354 const Twine &Spelling,
355 Option::OptionClass OptClass,
unsigned,
356 const Twine &
Value) {
358 case Option::SeparateClass:
359 case Option::JoinedOrSeparateClass:
360 case Option::JoinedAndSeparateClass:
364 case Option::JoinedClass:
365 case Option::CommaJoinedClass:
366 Consumer(Spelling +
Value);
369 llvm_unreachable(
"Cannot denormalize an option with option class "
370 "incompatible with string denormalization.");
376 Option::OptionClass OptClass,
unsigned TableIndex,
381static std::optional<SimpleEnumValue>
383 for (
int I = 0,
E = Table.Size; I !=
E; ++I)
384 if (Name == Table.Table[I].Name)
385 return Table.Table[I];
390static std::optional<SimpleEnumValue>
392 for (
int I = 0,
E = Table.Size; I !=
E; ++I)
394 return Table.Table[I];
403 assert(TableIndex < SimpleEnumValueTablesSize);
404 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
406 auto *Arg = Args.getLastArg(Opt);
410 StringRef ArgValue = Arg->getValue();
412 return MaybeEnumVal->Value;
414 Diags.
Report(diag::err_drv_invalid_value)
415 << Arg->getAsString(Args) << ArgValue;
420 const Twine &Spelling,
421 Option::OptionClass OptClass,
422 unsigned TableIndex,
unsigned Value) {
423 assert(TableIndex < SimpleEnumValueTablesSize);
424 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
429 llvm_unreachable(
"The simple enum value was not correctly defined in "
430 "the tablegen option description");
436 const Twine &Spelling,
437 Option::OptionClass OptClass,
438 unsigned TableIndex,
T Value) {
440 static_cast<unsigned>(
Value));
447 auto *Arg = Args.getLastArg(Opt);
450 return std::string(Arg->getValue());
453template <
typename IntTy>
457 auto *Arg = Args.getLastArg(Opt);
461 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
462 Diags.
Report(diag::err_drv_invalid_int_value)
463 << Arg->getAsString(Args) << Arg->getValue();
469static std::optional<std::vector<std::string>>
472 return Args.getAllArgValues(Opt);
476 const Twine &Spelling,
477 Option::OptionClass OptClass,
479 const std::vector<std::string> &Values) {
481 case Option::CommaJoinedClass: {
482 std::string CommaJoinedValue;
483 if (!Values.empty()) {
484 CommaJoinedValue.append(Values.front());
485 for (
const std::string &
Value : llvm::drop_begin(Values, 1)) {
486 CommaJoinedValue.append(
",");
487 CommaJoinedValue.append(
Value);
491 TableIndex, CommaJoinedValue);
494 case Option::JoinedClass:
495 case Option::SeparateClass:
496 case Option::JoinedOrSeparateClass:
497 for (
const std::string &
Value : Values)
501 llvm_unreachable(
"Cannot denormalize an option with option class "
502 "incompatible with string vector denormalization.");
510 auto *Arg = Args.getLastArg(Opt);
513 return llvm::Triple::normalize(Arg->getValue());
516template <
typename T,
typename U>
518 return static_cast<T>(
Value);
522 return KeyPath |
Value;
529template <
typename T,
typename U, U Value>
534#define PARSE_OPTION_WITH_MARSHALLING( \
535 ARGS, DIAGS, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, \
536 FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
537 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
538 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
539 if ((VISIBILITY) & options::CC1Option) { \
540 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
542 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
544 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
546 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
551#define GENERATE_OPTION_WITH_MARSHALLING( \
552 CONSUMER, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, \
553 VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
554 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
555 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
556 if ((VISIBILITY) & options::CC1Option) { \
557 [&](const auto &Extracted) { \
560 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
561 : (DEFAULT_VALUE)))) \
562 DENORMALIZER(CONSUMER, SPELLING, Option::KIND##Class, TABLE_INDEX, \
564 }(EXTRACTOR(KEYPATH)); \
578 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
579 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
580 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
581 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
584 CodeGenOpts.ClearASTBeforeBackend =
false;
586 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
587 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
590 llvm::Triple
T(TargetOpts.
Triple);
591 llvm::Triple::ArchType Arch =
T.getArch();
596 if (LangOpts.getExceptionHandling() !=
598 T.isWindowsMSVCEnvironment())
599 Diags.
Report(diag::err_fe_invalid_exception_model)
600 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) <<
T.str();
602 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
603 Diags.
Report(diag::warn_c_kext);
605 if (LangOpts.NewAlignOverride &&
606 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
607 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
608 Diags.
Report(diag::err_fe_invalid_alignment)
609 << A->getAsString(Args) << A->getValue();
610 LangOpts.NewAlignOverride = 0;
615 if (LangOpts.CPlusPlus11) {
616 if (Args.hasArg(OPT_fraw_string_literals, OPT_fno_raw_string_literals)) {
617 Args.claimAllArgs(OPT_fraw_string_literals, OPT_fno_raw_string_literals);
618 Diags.
Report(diag::warn_drv_fraw_string_literals_in_cxx11)
619 <<
bool(LangOpts.RawStringLiterals);
623 LangOpts.RawStringLiterals =
true;
627 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
628 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
631 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
632 Diags.
Report(diag::err_drv_argument_not_allowed_with)
635 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
636 Diags.
Report(diag::err_drv_argument_not_allowed_with)
639 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
640 Diags.
Report(diag::warn_ignored_hip_only_option)
641 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
643 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
644 Diags.
Report(diag::warn_ignored_hip_only_option)
645 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
654 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
655 if (LangOpts.ApproxFunc)
656 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
657 if (LangOpts.AllowFPReassoc)
658 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
659 if (LangOpts.AllowRecip)
660 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
666 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
668 Diags.
Report(diag::warn_option_invalid_ocl_version)
670 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
672 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
673 auto DefaultCC = LangOpts.getDefaultCallingConv();
677 Arch != llvm::Triple::x86;
683 Diags.
Report(diag::err_drv_argument_not_allowed_with)
684 << A->getSpelling() <<
T.getTriple();
696 unsigned DefaultOpt = 0;
699 !Args.hasArg(OPT_cl_opt_disable))
702 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
703 if (A->getOption().matches(options::OPT_O0))
706 if (A->getOption().matches(options::OPT_Ofast))
709 assert(A->getOption().matches(options::OPT_O));
711 StringRef S(A->getValue());
712 if (S ==
"s" || S ==
"z")
725 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
726 if (A->getOption().matches(options::OPT_O)) {
727 switch (A->getValue()[0]) {
741 llvm::opt::OptSpecifier OptSpecifier) {
744 Option::OptionClass::FlagClass, 0);
748 llvm::opt::OptSpecifier OptSpecifier,
749 const Twine &
Value) {
787 bool CheckAgainstOriginalInvocation =
false,
788 bool ForceRoundTrip =
false) {
790 bool DoRoundTripDefault =
true;
792 bool DoRoundTripDefault =
false;
795 bool DoRoundTrip = DoRoundTripDefault;
796 if (ForceRoundTrip) {
799 for (
const auto *Arg : CommandLineArgs) {
800 if (Arg == StringRef(
"-round-trip-args"))
802 if (Arg == StringRef(
"-no-round-trip-args"))
810 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
815 llvm::raw_string_ostream OS(Buffer);
816 for (
const char *Arg : Args) {
817 llvm::sys::printArg(OS, Arg,
true);
830 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
837 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
843 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
844 Diags.
Report(diag::note_cc1_round_trip_original)
845 << SerializeArgs(CommandLineArgs);
850 llvm::BumpPtrAllocator Alloc;
851 llvm::StringSaver StringPool(Alloc);
852 auto SA = [&StringPool](
const Twine &Arg) {
853 return StringPool.save(Arg).data();
860 Generate(DummyInvocation, GeneratedArgs, SA);
866 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
871 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
872 Diags.
Report(diag::note_cc1_round_trip_generated)
873 << 1 << SerializeArgs(GeneratedArgs);
878 if (CheckAgainstOriginalInvocation)
880 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
884 Generate(RealInvocation, ComparisonArgs, SA);
889 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
890 [](
const char *AElem,
const char *BElem) {
891 return StringRef(AElem) == StringRef(BElem);
898 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
899 Diags.
Report(diag::err_cc1_round_trip_mismatch);
900 Diags.
Report(diag::note_cc1_round_trip_generated)
901 << 1 << SerializeArgs(GeneratedArgs);
902 Diags.
Report(diag::note_cc1_round_trip_generated)
903 << 2 << SerializeArgs(ComparisonArgs);
907 Diags.
Report(diag::remark_cc1_round_trip_generated)
908 << 1 << SerializeArgs(GeneratedArgs);
909 Diags.
Report(diag::remark_cc1_round_trip_generated)
910 << 2 << SerializeArgs(ComparisonArgs);
922 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
926 Args.push_back(
"-cc1");
929 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
934 OptSpecifier GroupWithValue,
935 std::vector<std::string> &Diagnostics) {
936 for (
auto *A : Args.filtered(Group)) {
937 if (A->getOption().getKind() == Option::FlagClass) {
940 Diagnostics.push_back(
941 std::string(A->getOption().getName().drop_front(1)));
942 }
else if (A->getOption().matches(GroupWithValue)) {
945 Diagnostics.push_back(
946 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
949 Diagnostics.push_back(A->getValue());
960 std::vector<std::string> &Funcs) {
961 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
963 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
970#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
971 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
972#include "clang/Driver/Options.inc"
973#undef ANALYZER_OPTION_WITH_MARSHALLING
977#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
979 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \
981#include "clang/StaticAnalyzer/Core/Analyses.def"
983 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
989#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
991 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \
993#include "clang/StaticAnalyzer/Core/Analyses.def"
995 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
1001#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1003 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \
1005#include "clang/StaticAnalyzer/Core/Analyses.def"
1007 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
1013#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1015 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \
1017#include "clang/StaticAnalyzer/Core/Analyses.def"
1019 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
1025 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
1034 for (
const auto &
C : Opts.
Config)
1035 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
1036 llvm::sort(SortedConfigOpts, llvm::less_first());
1038 for (
const auto &[Key,
Value] : SortedConfigOpts) {
1041 auto Entry = ConfigOpts.
Config.find(Key);
1042 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
1057#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
1058 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1059#include "clang/Driver/Options.inc"
1060#undef ANALYZER_OPTION_WITH_MARSHALLING
1062 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
1063 StringRef Name = A->getValue();
1065#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1066 .Case(CMDFLAG, NAME##Model)
1067#include "clang/StaticAnalyzer/Core/Analyses.def"
1070 Diags.
Report(diag::err_drv_invalid_value)
1071 << A->getAsString(Args) << Name;
1074 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
1075 Diags.
Report(diag::err_analyzer_not_built_with_z3);
1082 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
1083 StringRef Name = A->getValue();
1085#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1086 .Case(CMDFLAG, PD_##NAME)
1087#include "clang/StaticAnalyzer/Core/Analyses.def"
1090 Diags.
Report(diag::err_drv_invalid_value)
1091 << A->getAsString(Args) << Name;
1097 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
1098 StringRef Name = A->getValue();
1100#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1101 .Case(CMDFLAG, NAME)
1102#include "clang/StaticAnalyzer/Core/Analyses.def"
1105 Diags.
Report(diag::err_drv_invalid_value)
1106 << A->getAsString(Args) << Name;
1112 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
1113 StringRef Name = A->getValue();
1115#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1116 .Case(CMDFLAG, NAME)
1117#include "clang/StaticAnalyzer/Core/Analyses.def"
1120 Diags.
Report(diag::err_drv_invalid_value)
1121 << A->getAsString(Args) << Name;
1129 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1131 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1134 StringRef CheckerAndPackageList = A->getValue();
1136 CheckerAndPackageList.split(CheckersAndPackages,
",");
1137 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1143 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1147 StringRef configList = A->getValue();
1149 configList.split(configVals,
",");
1150 for (
const auto &configVal : configVals) {
1152 std::tie(key, val) = configVal.split(
"=");
1155 diag::err_analyzer_config_no_value) << configVal;
1158 if (val.contains(
'=')) {
1160 diag::err_analyzer_config_multiple_values)
1169 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1174 Opts.
Config[key] = std::string(val);
1184 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1187 os << Args.getArgString(i);
1195 StringRef OptionName, StringRef DefaultVal) {
1196 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1201 StringRef &OptionField, StringRef Name,
1202 StringRef DefaultVal) {
1211 bool &OptionField, StringRef Name,
bool DefaultVal) {
1212 auto PossiblyInvalidVal =
1213 llvm::StringSwitch<std::optional<bool>>(
1216 .Case(
"false",
false)
1217 .Default(std::nullopt);
1219 if (!PossiblyInvalidVal) {
1221 Diags->
Report(diag::err_analyzer_config_invalid_input)
1222 << Name <<
"a boolean";
1224 OptionField = DefaultVal;
1226 OptionField = *PossiblyInvalidVal;
1231 unsigned &OptionField, StringRef Name,
1232 unsigned DefaultVal) {
1234 OptionField = DefaultVal;
1235 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1236 .getAsInteger(0, OptionField);
1237 if (Diags && HasFailed)
1238 Diags->
Report(diag::err_analyzer_config_invalid_input)
1239 << Name <<
"an unsigned";
1247#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1248 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1249#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1250#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1252 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1253 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1255#define ANALYZER_OPTION(...)
1256#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1257 SHALLOW_VAL, DEEP_VAL) \
1258 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1259 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1260#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1267 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1268 std::vector<StringRef> Checkers =
1270 std::vector<StringRef> Packages =
1274 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1276 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1278 bool IsChecker = CheckerOrPackage.contains(
'.');
1279 bool IsValidName = IsChecker
1280 ? llvm::is_contained(Checkers, CheckerOrPackage)
1281 : llvm::is_contained(Packages, CheckerOrPackage);
1284 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1285 << CheckerOrPackage;
1295 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1296 Diags->
Report(diag::err_analyzer_config_invalid_input)
1297 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1299 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1300 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1303 if (!AnOpts.ModelPath.empty() &&
1304 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1305 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1314 if (
Remark.hasValidPattern()) {
1319 GenerateArg(Consumer, OPT_R_Joined, StringRef(
"no-") + Name);
1328 OptSpecifier OptEQ, StringRef Name) {
1331 auto InitializeResultPattern = [&Diags, &Args, &
Result](
const Arg *A,
1332 StringRef Pattern) {
1333 Result.Pattern = Pattern.str();
1335 std::string RegexError;
1336 Result.Regex = std::make_shared<llvm::Regex>(
Result.Pattern);
1337 if (!
Result.Regex->isValid(RegexError)) {
1338 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1339 << RegexError << A->getAsString(Args);
1346 for (Arg *A : Args) {
1347 if (A->getOption().matches(OPT_R_Joined)) {
1348 StringRef
Value = A->getValue();
1352 else if (
Value ==
"everything")
1354 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1356 else if (
Value ==
"no-everything")
1366 InitializeResultPattern(A,
".*");
1368 }
else if (A->getOption().matches(OptEQ)) {
1370 if (!InitializeResultPattern(A, A->getValue()))
1379 const std::vector<std::string> &Levels,
1383 for (
const auto &Level : Levels) {
1385 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1393 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1401 const std::vector<std::string> &Sanitizers,
1403 for (
const auto &Sanitizer : Sanitizers) {
1406 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1422 llvm::SplitString(Bundle, BundleParts,
",");
1423 for (
const auto &B : BundleParts) {
1427 D.Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1441 llvm::raw_string_ostream OS(Buffer);
1442 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1448 const Twine &ProfileName,
1449 llvm::vfs::FileSystem &FS,
1451 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);
1452 if (
auto E = ReaderOrErr.takeError()) {
1454 "Error in reading profile %0: %1");
1455 llvm::handleAllErrors(std::move(
E), [&](
const llvm::ErrorInfoBase &EI) {
1456 Diags.
Report(DiagID) << ProfileName.str() << EI.message();
1460 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1461 std::move(ReaderOrErr.get());
1465 if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1466 if (PGOReader->hasCSIRLevelProfile())
1476 const llvm::Triple &Triple) {
1477 assert(Triple.getArch() == llvm::Triple::aarch64);
1484 LangOpts.PointerAuthFunctionTypeDiscrimination ? Discrimination::Type
1485 : Discrimination::None);
1488 Key::ASDA,
LangOpts.PointerAuthVTPtrAddressDiscrimination,
1489 LangOpts.PointerAuthVTPtrTypeDiscrimination ? Discrimination::Type
1490 : Discrimination::None);
1492 if (
LangOpts.PointerAuthTypeInfoVTPtrDiscrimination)
1507 if (
LangOpts.PointerAuthInitFini) {
1509 Key::ASIA,
LangOpts.PointerAuthInitFiniAddressDiscrimination,
1520 const llvm::Triple &Triple,
1522 if (!LangOpts.PointerAuthCalls && !LangOpts.PointerAuthReturns &&
1523 !LangOpts.PointerAuthAuthTraps && !LangOpts.PointerAuthIndirectGotos)
1529void CompilerInvocationBase::GenerateCodeGenArgs(
const CodeGenOptions &Opts,
1531 const llvm::Triple &
T,
1532 const std::string &OutputFile,
1536 if (Opts.OptimizationLevel == 0)
1539 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));
1541#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1542 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
1543#include "clang/Driver/Options.inc"
1544#undef CODEGEN_OPTION_WITH_MARSHALLING
1546 if (Opts.OptimizationLevel > 0) {
1550 GenerateArg(Consumer, OPT_finline_hint_functions);
1555 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1556 GenerateArg(Consumer, OPT_fdirect_access_external_data);
1557 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1558 GenerateArg(Consumer, OPT_fno_direct_access_external_data);
1560 std::optional<StringRef> DebugInfoVal;
1561 switch (Opts.DebugInfo) {
1562 case llvm::codegenoptions::DebugLineTablesOnly:
1563 DebugInfoVal =
"line-tables-only";
1565 case llvm::codegenoptions::DebugDirectivesOnly:
1566 DebugInfoVal =
"line-directives-only";
1568 case llvm::codegenoptions::DebugInfoConstructor:
1569 DebugInfoVal =
"constructor";
1571 case llvm::codegenoptions::LimitedDebugInfo:
1572 DebugInfoVal =
"limited";
1574 case llvm::codegenoptions::FullDebugInfo:
1575 DebugInfoVal =
"standalone";
1577 case llvm::codegenoptions::UnusedTypeInfo:
1578 DebugInfoVal =
"unused-types";
1580 case llvm::codegenoptions::NoDebugInfo:
1581 DebugInfoVal = std::nullopt;
1583 case llvm::codegenoptions::LocTrackingOnly:
1584 DebugInfoVal = std::nullopt;
1588 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
1592 Prefix.first +
"=" + Prefix.second);
1595 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
1596 Prefix.first +
"=" + Prefix.second);
1598 if (Opts.NewStructPathTBAA)
1601 if (Opts.OptimizeSize == 1)
1603 else if (Opts.OptimizeSize == 2)
1611 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1613 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1619 if (Opts.DebugNameTable ==
1620 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1622 else if (Opts.DebugNameTable ==
1623 static_cast<unsigned>(
1624 llvm::DICompileUnit::DebugNameTableKind::Default))
1627 if (Opts.DebugTemplateAlias)
1630 auto TNK = Opts.getDebugSimpleTemplateNames();
1631 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1632 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1633 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"simple");
1634 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1635 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"mangled");
1640 if (Opts.TimePasses) {
1641 if (Opts.TimePassesPerRun)
1642 GenerateArg(Consumer, OPT_ftime_report_EQ,
"per-pass-run");
1647 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1650 if (Opts.PrepareForThinLTO)
1659 StringRef MemProfileBasename(
"memprof.profraw");
1680 std::string InstrBundle =
1682 if (!InstrBundle.empty())
1683 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);
1686 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1687 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"full");
1688 else if (Opts.CFProtectionReturn)
1689 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"return");
1690 else if (Opts.CFProtectionBranch)
1691 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"branch");
1693 if (Opts.FunctionReturnThunks)
1694 GenerateArg(Consumer, OPT_mfunction_return_EQ,
"thunk-extern");
1697 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1698 F.PropagateAttrs && F.Internalize;
1700 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1704 if (Opts.EmulatedTLS)
1712 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,
1717 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1721 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1725 if (Opts.EnableAIXExtendedAltivecABI)
1728 if (Opts.XCOFFReadOnlyPointers)
1746 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,
1751 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,
1755 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);
1758 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);
1760 if (!Opts.EmitVersionIdentMetadata)
1763 switch (Opts.FiniteLoops) {
1775bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1778 const llvm::Triple &
T,
1779 const std::string &OutputFile,
1785 unsigned MaxOptLevel = 3;
1786 if (OptimizationLevel > MaxOptLevel) {
1789 Diags.
Report(diag::warn_drv_optimization_value)
1790 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1791 OptimizationLevel = MaxOptLevel;
1793 Opts.OptimizationLevel = OptimizationLevel;
1802#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1803 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1804#include "clang/Driver/Options.inc"
1805#undef CODEGEN_OPTION_WITH_MARSHALLING
1809 if (Opts.OptimizationLevel == 0) {
1811 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1812 options::OPT_finline_hint_functions,
1813 options::OPT_fno_inline_functions,
1814 options::OPT_fno_inline)) {
1817 if (A->getOption().matches(options::OPT_finline_functions))
1819 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1829 Opts.DirectAccessExternalData =
1830 Args.hasArg(OPT_fdirect_access_external_data) ||
1831 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1834 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1836 llvm::StringSwitch<unsigned>(A->getValue())
1837 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1838 .Case(
"line-directives-only",
1839 llvm::codegenoptions::DebugDirectivesOnly)
1840 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1841 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1842 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1843 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1846 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1849 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1855 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1856 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1857 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1858 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1859 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1860 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1861 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1864 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1865 auto Split = StringRef(Arg).split(
'=');
1869 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1870 auto Split = StringRef(Arg).split(
'=');
1874 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1875 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1876 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1877 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1880 llvm::is_contained(DebugEntryValueArchs,
T.getArch()))
1881 Opts.EmitCallSiteInfo =
true;
1884 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1889 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1890 Args.hasArg(OPT_new_struct_path_tbaa);
1892 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1893 if (Opts.SimplifyLibCalls)
1896 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1897 (Opts.OptimizationLevel > 1));
1899 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1901 Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);
1903 Opts.DebugNameTable =
static_cast<unsigned>(
1904 Args.hasArg(OPT_ggnu_pubnames)
1905 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1906 : Args.hasArg(OPT_gpubnames)
1907 ? llvm::DICompileUnit::DebugNameTableKind::Default
1908 : llvm::DICompileUnit::DebugNameTableKind::None);
1909 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1910 StringRef
Value = A->getValue();
1912 Diags.
Report(diag::err_drv_unsupported_option_argument)
1913 << A->getSpelling() << A->getValue();
1914 Opts.setDebugSimpleTemplateNames(
1915 StringRef(A->getValue()) ==
"simple"
1916 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
1917 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
1920 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1921 Opts.TimePasses =
true;
1924 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1925 StringRef Val = A->getValue();
1926 if (Val ==
"per-pass")
1927 Opts.TimePassesPerRun =
false;
1928 else if (Val ==
"per-pass-run")
1929 Opts.TimePassesPerRun =
true;
1931 Diags.
Report(diag::err_drv_invalid_value)
1932 << A->getAsString(Args) << A->getValue();
1936 Opts.PrepareForLTO =
false;
1937 Opts.PrepareForThinLTO =
false;
1938 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1939 Opts.PrepareForLTO =
true;
1940 StringRef S = A->getValue();
1942 Opts.PrepareForThinLTO =
true;
1943 else if (S !=
"full")
1944 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1945 if (Args.hasArg(OPT_funified_lto))
1946 Opts.PrepareForThinLTO =
true;
1948 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1950 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1951 << A->getAsString(Args) <<
"-x ir";
1953 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1955 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1957 llvm::StringSwitch<std::string>(A->getValue())
1958 .Case(
"obj", OutputFile)
1959 .Default(llvm::sys::path::filename(OutputFile).str());
1962 const char *MemProfileBasename =
"memprof.profraw";
1963 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1965 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1966 llvm::sys::path::append(
Path, MemProfileBasename);
1968 }
else if (Args.hasArg(OPT_fmemory_profile))
1973 if (Args.hasArg(OPT_coverage_version_EQ)) {
1974 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1975 if (CoverageVersion.size() != 4) {
1976 Diags.
Report(diag::err_drv_invalid_value)
1977 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1987 for (
const auto &A : Args) {
1989 if (A->getOption().getID() == options::OPT_o ||
1990 A->getOption().getID() == options::OPT_INPUT ||
1991 A->getOption().getID() == options::OPT_x ||
1992 A->getOption().getID() == options::OPT_fembed_bitcode ||
1993 A->getOption().matches(options::OPT_W_Group))
1996 A->render(Args, ASL);
1997 for (
const auto &arg : ASL) {
1998 StringRef ArgStr(arg);
1999 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
2005 auto XRayInstrBundles =
2006 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
2007 if (XRayInstrBundles.empty())
2010 for (
const auto &A : XRayInstrBundles)
2014 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
2015 StringRef Name = A->getValue();
2016 if (Name ==
"full") {
2017 Opts.CFProtectionReturn = 1;
2018 Opts.CFProtectionBranch = 1;
2019 }
else if (Name ==
"return")
2020 Opts.CFProtectionReturn = 1;
2021 else if (Name ==
"branch")
2022 Opts.CFProtectionBranch = 1;
2023 else if (Name !=
"none")
2024 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
2027 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
2028 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
2029 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
2030 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
2031 .Default(llvm::FunctionReturnThunksKind::Invalid);
2034 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2035 << A->getSpelling() <<
T.getTriple();
2036 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
2037 Diags.
Report(diag::err_drv_invalid_value)
2038 << A->getAsString(Args) << A->getValue();
2039 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
2040 Args.getLastArgValue(OPT_mcmodel_EQ) ==
"large")
2041 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2042 << A->getAsString(Args)
2043 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
2045 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
2049 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
2052 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
2053 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
2062 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
2063 StringRef Val = A->getValue();
2067 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2070 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
2071 StringRef Val = A->getValue();
2074 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2080 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
2081 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
2085 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2086 << A->getSpelling() <<
T.str();
2088 const Option &O = A->getOption();
2089 if (O.matches(OPT_fpcc_struct_return) ||
2090 O.matches(OPT_maix_struct_return)) {
2093 assert(O.matches(OPT_freg_struct_return) ||
2094 O.matches(OPT_msvr4_struct_return));
2099 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {
2101 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2102 << A->getSpelling() <<
T.str();
2112 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,
false))
2113 Diags.
Report(diag::err_roptr_requires_data_sections);
2115 Opts.XCOFFReadOnlyPointers =
true;
2118 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
2119 if (!
T.isOSAIX() ||
T.isPPC32())
2120 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2121 << A->getSpelling() <<
T.str();
2124 bool NeedLocTracking =
false;
2127 NeedLocTracking =
true;
2129 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
2131 NeedLocTracking =
true;
2134 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
2136 NeedLocTracking =
true;
2146 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
2156 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
2159 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2160 <<
"-fdiagnostics-show-hotness";
2164 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2166 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2169 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2170 <<
"-fdiagnostics-hotness-threshold=";
2176 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2177 <<
"-fdiagnostics-hotness-threshold=";
2182 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2186 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2187 <<
"-fdiagnostics-misexpect-tolerance=";
2193 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2194 <<
"-fdiagnostics-misexpect-tolerance=";
2201 if (UsingSampleProfile)
2202 NeedLocTracking =
true;
2205 NeedLocTracking =
true;
2209 if (NeedLocTracking &&
2210 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2211 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2216 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2219 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2222 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2227 if (Args.hasArg(options::OPT_ffinite_loops))
2229 else if (Args.hasArg(options::OPT_fno_finite_loops))
2232 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2233 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2234 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2235 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2243#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2244 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2245#include "clang/Driver/Options.inc"
2246#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2251 for (
const auto &Dep : Opts.
ExtraDeps) {
2252 switch (Dep.second) {
2265 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);
2274 bool ShowLineMarkers) {
2278#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2279 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2280#include "clang/Driver/Options.inc"
2281#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2283 if (Args.hasArg(OPT_show_includes)) {
2298 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2299 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2300 StringRef Val = A->getValue();
2301 if (!Val.contains(
'='))
2305 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2306 StringRef Val = A->getValue();
2307 if (!Val.contains(
'='))
2314 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2318 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2322 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2323 StringRef Val = A->getValue();
2324 if (!Val.contains(
'='))
2334 Diags.
Report(diag::err_drv_print_header_env_var_combination_cc1)
2335 << Args.getLastArg(OPT_header_include_format_EQ)->getValue()
2336 << Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();
2350 }
ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2351 for (
auto *A : Args) {
2352 const Option &O = A->getOption();
2353 if (O.matches(options::OPT_fcolor_diagnostics)) {
2355 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2357 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2358 StringRef
Value(A->getValue());
2359 if (
Value ==
"always")
2361 else if (
Value ==
"never")
2363 else if (
Value ==
"auto")
2369 llvm::sys::Process::StandardErrHasColors());
2375 for (
const auto &Prefix : VerifyPrefixes) {
2378 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2381 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2383 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2384 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2394#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2395 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2396#include "clang/Driver/Options.inc"
2397#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2406#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2407 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2408#include "clang/Driver/Options.inc"
2409#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2417#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2418 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2419#include "clang/Driver/Options.inc"
2420#undef MIGRATOR_OPTION_WITH_MARSHALLING
2429#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2430 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2431#include "clang/Driver/Options.inc"
2432#undef MIGRATOR_OPTION_WITH_MARSHALLING
2437void CompilerInvocationBase::GenerateDiagnosticArgs(
2439 bool DefaultDiagColor) {
2441#define DIAG_OPTION_WITH_MARSHALLING(...) \
2442 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2443#include "clang/Driver/Options.inc"
2444#undef DIAG_OPTION_WITH_MARSHALLING
2447 GenerateArg(Consumer, OPT_diagnostic_serialized_file,
2450 if (Opts.ShowColors)
2453 if (Opts.VerifyDiagnostics &&
2458 if (Prefix !=
"expected")
2465 GenerateArg(Consumer, OPT_verify_ignore_unexpected);
2468 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"note");
2470 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"remark");
2472 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"warning");
2474 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"error");
2479 if (
Warning ==
"undef-prefix")
2482 if (
Warning ==
"invalid-constexpr" ||
Warning ==
"no-invalid-constexpr")
2484 Consumer(StringRef(
"-W") +
Warning);
2490 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2491 "pass-analysis",
"no-pass-analysis",
2492 "pass-missed",
"no-pass-missed"};
2493 if (llvm::is_contained(IgnoredRemarks,
Remark))
2496 Consumer(StringRef(
"-R") +
Remark);
2500std::unique_ptr<DiagnosticOptions>
2502 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2503 unsigned MissingArgIndex, MissingArgCount;
2505 Argv.slice(1), MissingArgIndex, MissingArgCount);
2508 if (std::optional<std::string> NoColor =
2509 llvm::sys::Process::GetEnv(
"NO_COLOR");
2510 NoColor && !NoColor->empty()) {
2525 bool DefaultDiagColor) {
2526 std::optional<DiagnosticsEngine> IgnoringDiags;
2530 Diags = &*IgnoringDiags;
2539#define DIAG_OPTION_WITH_MARSHALLING(...) \
2540 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2541#include "clang/Driver/Options.inc"
2542#undef DIAG_OPTION_WITH_MARSHALLING
2544 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2547 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2551 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2553 if (Args.hasArg(OPT_verify))
2558 Opts.VerifyDiagnostics =
false;
2563 "-verify-ignore-unexpected=",
2564 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2565 if (Args.hasArg(OPT_verify_ignore_unexpected))
2567 Opts.setVerifyIgnoreUnexpected(DiagMask);
2569 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2585 std::string &BlockName,
2586 unsigned &MajorVersion,
2587 unsigned &MinorVersion,
2589 std::string &UserInfo) {
2591 Arg.split(Args,
':', 5);
2592 if (Args.size() < 5)
2595 BlockName = std::string(Args[0]);
2596 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2597 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2598 if (Args[3].getAsInteger(2, Hashed))
return true;
2599 if (Args.size() > 4)
2600 UserInfo = std::string(Args[4]);
2609 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2640 OPT_emit_reduced_module_interface},
2658 OPT_print_dependency_directives_minimized_source},
2665static std::optional<frontend::ActionKind>
2668 if (ActionOpt.second == Opt.getID())
2669 return ActionOpt.first;
2671 return std::nullopt;
2675static std::optional<OptSpecifier>
2678 if (ActionOpt.first == ProgramAction)
2679 return OptSpecifier(ActionOpt.second);
2681 return std::nullopt;
2687#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2688 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2689#include "clang/Driver/Options.inc"
2690#undef FRONTEND_OPTION_WITH_MARSHALLING
2692 std::optional<OptSpecifier> ProgramActionOpt =
2696 std::function<void()> GenerateProgramAction = [&]() {
2700 if (!ProgramActionOpt) {
2703 "Frontend action without option.");
2704 GenerateProgramAction = [&]() {
2711 GenerateProgramAction = [&]() {
2719 llvm_unreachable(
"Default AST dump format.");
2726 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);
2739 GenerateProgramAction = [&]() {
2744 GenerateProgramAction();
2746 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2748 for (
const auto &PluginArg : PluginArgs.second)
2750 Opt.getPrefix() + Opt.getName() + PluginArgs.first,
2751 Opt.getKind(), 0, PluginArg);
2755 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2756 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());
2762 for (
const auto &Plugin : Opts.
Plugins)
2768 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);
2775 GenerateArg(Consumer, OPT_aux_target_feature, Feature);
2781 StringRef HeaderUnit =
"";
2786 HeaderUnit =
"-user";
2789 HeaderUnit =
"-system";
2792 HeaderUnit =
"-header-unit";
2795 StringRef Header = IsHeader ?
"-header" :
"";
2818 Lang =
"objective-c";
2821 Lang =
"objective-c++";
2824 Lang =
"renderscript";
2827 Lang =
"assembler-with-cpp";
2831 "Generating -x argument for unknown language (not precompiled).");
2846 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed);
2850 for (
const auto &Input : Opts.
Inputs)
2851 Consumer(Input.getFile());
2860#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2861 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2862#include "clang/Driver/Options.inc"
2863#undef FRONTEND_OPTION_WITH_MARSHALLING
2866 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2867 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2869 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2872 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2873 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2876 .Default(std::numeric_limits<unsigned>::max());
2878 if (Val != std::numeric_limits<unsigned>::max())
2881 Diags.
Report(diag::err_drv_invalid_value)
2882 << A->getAsString(Args) << A->getValue();
2892 Args.hasArg(OPT_interface_stub_version_EQ)
2893 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2895 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2896 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2897 ArgStr ==
"experimental-tapi-elf-v1") {
2898 std::string ErrorMessage =
2899 "Invalid interface stub format: " + ArgStr.str() +
2901 Diags.
Report(diag::err_drv_invalid_value)
2902 <<
"Must specify a valid interface stub format type, ie: "
2903 "-interface-stub-version=ifs-v1"
2906 }
else if (!ArgStr.starts_with(
"ifs-")) {
2907 std::string ErrorMessage =
2908 "Invalid interface stub format: " + ArgStr.str() +
".";
2909 Diags.
Report(diag::err_drv_invalid_value)
2910 <<
"Must specify a valid interface stub format type, ie: "
2911 "-interface-stub-version=ifs-v1"
2926 if (!A->getSpelling().starts_with(
"-ast-dump")) {
2927 const Arg *SavedAction =
nullptr;
2928 for (
const Arg *AA :
2929 Args.filtered(OPT_Action_Group, OPT_main_file_name)) {
2930 if (AA->getOption().matches(OPT_main_file_name)) {
2931 SavedAction =
nullptr;
2932 }
else if (!SavedAction) {
2935 if (!A->getOption().matches(OPT_ast_dump_EQ))
2936 Diags.
Report(diag::err_fe_invalid_multiple_actions)
2937 << SavedAction->getSpelling() << A->getSpelling();
2944 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2945 Opts.
Plugins.emplace_back(A->getValue(0));
2949 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2950 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2952 for (
const std::string &Arg :
2953 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2954 std::string BlockName;
2955 unsigned MajorVersion;
2956 unsigned MinorVersion;
2958 std::string UserInfo;
2960 MinorVersion, Hashed, UserInfo)) {
2961 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2968 std::make_shared<TestModuleFileExtension>(
2969 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2972 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2976 Diags.
Report(diag::err_drv_invalid_value)
2977 << A->getAsString(Args) << A->getValue();
2980 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2981 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2982 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2984 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2985 StringRef Val = A->getValue();
2986 if (!Val.contains(
'='))
2991 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2993 if (Args.hasArg(OPT_fclangir) || Args.hasArg(OPT_emit_cir))
2996 if (Args.hasArg(OPT_aux_target_cpu))
2997 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
2998 if (Args.hasArg(OPT_aux_target_feature))
3003 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3004 <<
"ARC migration" <<
"ObjC migration";
3008 if (
const Arg *A = Args.getLastArg(OPT_x)) {
3009 StringRef XValue = A->getValue();
3014 bool Preprocessed = XValue.consume_back(
"-cpp-output");
3015 bool ModuleMap = XValue.consume_back(
"-module-map");
3018 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
3024 if (IsHeader || Preprocessed) {
3025 if (XValue.consume_back(
"-header-unit"))
3027 else if (XValue.consume_back(
"-system"))
3029 else if (XValue.consume_back(
"-user"))
3035 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
3039 DashX = llvm::StringSwitch<InputKind>(XValue)
3056 DashX = llvm::StringSwitch<InputKind>(XValue)
3064 DashX = llvm::StringSwitch<InputKind>(XValue)
3067 .Cases(
"ast",
"pcm",
"precompiled-header",
3074 Diags.
Report(diag::err_drv_invalid_value)
3075 << A->getAsString(Args) << A->getValue();
3082 IsHeaderFile =
true;
3083 }
else if (IsHeaderFile)
3090 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
3093 Inputs.push_back(
"-");
3097 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
3099 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
3103 StringRef(Inputs[i]).rsplit(
'.').second);
3112 bool IsSystem =
false;
3121 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
3131 std::string ClangExecutable =
3132 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
3139#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3140 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3141#include "clang/Driver/Options.inc"
3142#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3157 GenerateArg(Consumer, OPT_fmodules_ignore_macro, Macro.val());
3161 std::optional<bool> IsFramework,
3162 std::optional<bool> IgnoreSysRoot) {
3163 return llvm::is_contained(Groups, Entry.
Group) &&
3164 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
3165 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
3173 std::nullopt,
true);
3175 OptSpecifier Opt = [It, Matches]() {
3184 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
3200 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3207 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3213 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3218 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);
3226 GenerateArg(Consumer, OPT_objc_isystem, It->Path);
3228 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);
3238 ? OPT_internal_isystem
3239 : OPT_internal_externc_isystem;
3243 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3247 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3248 : OPT_no_system_header_prefix;
3258 const std::string &WorkingDir) {
3263#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3264 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3265#include "clang/Driver/Options.inc"
3266#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3268 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3269 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3273 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3274 if (WorkingDir.empty())
3275 llvm::sys::fs::make_absolute(
P);
3277 llvm::sys::fs::make_absolute(WorkingDir,
P);
3279 llvm::sys::path::remove_dots(
P);
3283 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3284 StringRef Val = A->getValue();
3285 if (Val.contains(
'=')) {
3286 auto Split = Val.split(
'=');
3288 std::string(Split.first), std::string(Split.second));
3291 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3294 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3295 StringRef MacroDef = A->getValue();
3297 llvm::CachedHashString(MacroDef.split(
'=').first));
3301 bool IsIndexHeaderMap =
false;
3302 bool IsSysrootSpecified =
3303 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3307 auto PrefixHeaderPath = [IsSysrootSpecified,
3308 &Opts](
const llvm::opt::Arg *A,
3309 bool IsFramework =
false) -> std::string {
3310 assert(A->getNumValues() &&
"Unexpected empty search path flag!");
3311 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3313 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3314 llvm::StringRef(A->getValue()).substr(1));
3315 return std::string(Buffer);
3317 return A->getValue();
3320 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3321 if (A->getOption().matches(OPT_index_header_map)) {
3323 IsIndexHeaderMap =
true;
3330 bool IsFramework = A->getOption().matches(OPT_F);
3331 Opts.
AddPath(PrefixHeaderPath(A, IsFramework), Group, IsFramework,
3333 IsIndexHeaderMap =
false;
3337 StringRef Prefix =
"";
3338 for (
const auto *A :
3339 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3340 if (A->getOption().matches(OPT_iprefix))
3341 Prefix = A->getValue();
3342 else if (A->getOption().matches(OPT_iwithprefix))
3348 for (
const auto *A : Args.filtered(OPT_idirafter))
3350 for (
const auto *A : Args.filtered(OPT_iquote))
3353 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {
3354 if (A->getOption().matches(OPT_iwithsysroot)) {
3361 for (
const auto *A : Args.filtered(OPT_iframework))
3363 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3368 for (
const auto *A : Args.filtered(OPT_c_isystem))
3370 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3372 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3374 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3378 for (
const auto *A :
3379 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3381 if (A->getOption().matches(OPT_internal_externc_isystem))
3383 Opts.
AddPath(A->getValue(), Group,
false,
true);
3387 for (
const auto *A :
3388 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3390 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3392 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3401 GenerateArg(Consumer, OPT_fapinotes_swift_version,
3410 if (
const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {
3412 diags.
Report(diag::err_drv_invalid_value)
3413 << A->getAsString(Args) << A->getValue();
3415 for (
const Arg *A : Args.filtered(OPT_iapinotes_modules))
3421 if (Opts.PointerAuthIntrinsics)
3423 if (Opts.PointerAuthCalls)
3425 if (Opts.PointerAuthReturns)
3427 if (Opts.PointerAuthIndirectGotos)
3428 GenerateArg(Consumer, OPT_fptrauth_indirect_gotos);
3429 if (Opts.PointerAuthAuthTraps)
3431 if (Opts.PointerAuthVTPtrAddressDiscrimination)
3432 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_address_discrimination);
3433 if (Opts.PointerAuthVTPtrTypeDiscrimination)
3434 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_type_discrimination);
3435 if (Opts.PointerAuthTypeInfoVTPtrDiscrimination)
3436 GenerateArg(Consumer, OPT_fptrauth_type_info_vtable_pointer_discrimination);
3437 if (Opts.PointerAuthFunctionTypeDiscrimination)
3438 GenerateArg(Consumer, OPT_fptrauth_function_pointer_type_discrimination);
3439 if (Opts.PointerAuthInitFini)
3441 if (Opts.PointerAuthInitFiniAddressDiscrimination)
3442 GenerateArg(Consumer, OPT_fptrauth_init_fini_address_discrimination);
3447 Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);
3448 Opts.PointerAuthCalls = Args.hasArg(OPT_fptrauth_calls);
3449 Opts.PointerAuthReturns = Args.hasArg(OPT_fptrauth_returns);
3450 Opts.PointerAuthIndirectGotos = Args.hasArg(OPT_fptrauth_indirect_gotos);
3451 Opts.PointerAuthAuthTraps = Args.hasArg(OPT_fptrauth_auth_traps);
3452 Opts.PointerAuthVTPtrAddressDiscrimination =
3453 Args.hasArg(OPT_fptrauth_vtable_pointer_address_discrimination);
3454 Opts.PointerAuthVTPtrTypeDiscrimination =
3455 Args.hasArg(OPT_fptrauth_vtable_pointer_type_discrimination);
3456 Opts.PointerAuthTypeInfoVTPtrDiscrimination =
3457 Args.hasArg(OPT_fptrauth_type_info_vtable_pointer_discrimination);
3458 Opts.PointerAuthFunctionTypeDiscrimination =
3459 Args.hasArg(OPT_fptrauth_function_pointer_type_discrimination);
3460 Opts.PointerAuthInitFini = Args.hasArg(OPT_fptrauth_init_fini);
3461 Opts.PointerAuthInitFiniAddressDiscrimination =
3462 Args.hasArg(OPT_fptrauth_init_fini_address_discrimination);
3472 llvm_unreachable(
"should not parse language flags for this input");
3508 llvm_unreachable(
"unexpected input language");
3517 return "Objective-C";
3521 return "Objective-C++";
3525 return "C++ for OpenCL";
3529 return "RenderScript";
3546 llvm_unreachable(
"unknown input language");
3549void CompilerInvocationBase::GenerateLangArgs(
const LangOptions &Opts,
3551 const llvm::Triple &
T,
3556 if (Opts.ObjCAutoRefCount)
3558 if (Opts.PICLevel != 0)
3559 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));
3563 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3568 OptSpecifier StdOpt;
3570 case LangStandard::lang_opencl10:
3571 case LangStandard::lang_opencl11:
3572 case LangStandard::lang_opencl12:
3573 case LangStandard::lang_opencl20:
3574 case LangStandard::lang_opencl30:
3575 case LangStandard::lang_openclcpp10:
3576 case LangStandard::lang_openclcpp2021:
3577 StdOpt = OPT_cl_std_EQ;
3580 StdOpt = OPT_std_EQ;
3587 if (Opts.IncludeDefaultHeader)
3588 GenerateArg(Consumer, OPT_finclude_default_header);
3589 if (Opts.DeclareOpenCLBuiltins)
3590 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);
3594#define LANG_OPTION_WITH_MARSHALLING(...) \
3595 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3596#include "clang/Driver/Options.inc"
3597#undef LANG_OPTION_WITH_MARSHALLING
3608 else if (Opts.ObjCAutoRefCount == 1)
3611 if (Opts.ObjCWeakRuntime)
3612 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);
3617 if (Opts.ObjCSubscriptingLegacyRuntime)
3618 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);
3621 if (Opts.GNUCVersion != 0) {
3622 unsigned Major = Opts.GNUCVersion / 100 / 100;
3623 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3624 unsigned Patch = Opts.GNUCVersion % 100;
3626 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch));
3629 if (Opts.IgnoreXCOFFVisibility)
3630 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);
3639 if (Opts.MSCompatibilityVersion != 0) {
3640 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3641 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3642 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3643 GenerateArg(Consumer, OPT_fms_compatibility_version,
3644 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor));
3647 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3649 if (!Opts.Trigraphs)
3656 if (
T.isOSzOS() && !Opts.ZOSExt)
3658 else if (Opts.ZOSExt)
3661 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3664 if (Opts.ConvergentFunctions &&
3665 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice ||
3669 if (Opts.NoBuiltin && !Opts.Freestanding)
3672 if (!Opts.NoBuiltin)
3676 if (Opts.LongDoubleSize == 128)
3678 else if (Opts.LongDoubleSize == 64)
3680 else if (Opts.LongDoubleSize == 80)
3687 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3690 if (Opts.OpenMP != 51)
3691 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3693 if (!Opts.OpenMPUseTLS)
3696 if (Opts.OpenMPIsTargetDevice)
3697 GenerateArg(Consumer, OPT_fopenmp_is_target_device);
3699 if (Opts.OpenMPIRBuilder)
3700 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);
3703 if (Opts.OpenMPSimd) {
3706 if (Opts.OpenMP != 51)
3707 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3710 if (Opts.OpenMPThreadSubscription)
3711 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);
3713 if (Opts.OpenMPTeamSubscription)
3714 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);
3716 if (Opts.OpenMPTargetDebug != 0)
3717 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,
3718 Twine(Opts.OpenMPTargetDebug));
3720 if (Opts.OpenMPCUDANumSMs != 0)
3721 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,
3722 Twine(Opts.OpenMPCUDANumSMs));
3724 if (Opts.OpenMPCUDABlocksPerSM != 0)
3725 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3726 Twine(Opts.OpenMPCUDABlocksPerSM));
3728 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3729 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3730 Twine(Opts.OpenMPCUDAReductionBufNum));
3733 std::string Targets;
3734 llvm::raw_string_ostream OS(Targets);
3737 [&OS](
const llvm::Triple &
T) { OS << T.str(); },
",");
3738 GenerateArg(Consumer, OPT_fopenmp_targets_EQ, OS.str());
3744 if (Opts.OpenMPCUDAMode)
3764 GenerateArg(Consumer, OPT_ffp_contract,
"fast-honor-pragmas");
3767 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3771 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
3773 switch (Opts.getClangABICompat()) {
3775 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"3.8");
3778 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"4.0");
3781 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"6.0");
3784 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"7.0");
3787 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"9.0");
3790 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"11.0");
3793 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"12.0");
3796 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"14.0");
3799 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"15.0");
3802 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"17.0");
3805 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"18.0");
3811 if (Opts.getSignReturnAddressScope() ==
3813 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"all");
3814 else if (Opts.getSignReturnAddressScope() ==
3816 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"non-leaf");
3818 if (Opts.getSignReturnAddressKey() ==
3820 GenerateArg(Consumer, OPT_msign_return_address_key_EQ,
"b_key");
3826 if (Opts.RelativeCXXABIVTables)
3827 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);
3829 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);
3837 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second);
3843bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3845 std::vector<std::string> &Includes,
3855 if (Args.hasArg(OPT_fobjc_arc))
3856 Opts.ObjCAutoRefCount = 1;
3860 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3872 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3875 Diags.
Report(diag::err_drv_invalid_value)
3876 << A->getAsString(Args) << A->getValue();
3878 for (
unsigned KindValue = 0;
3884 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3885 Diag <<
Std.getName() <<
Std.getDescription();
3886 unsigned NumAliases = 0;
3887#define LANGSTANDARD(id, name, lang, desc, features)
3888#define LANGSTANDARD_ALIAS(id, alias) \
3889 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3890#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3891#include "clang/Basic/LangStandards.def"
3893#define LANGSTANDARD(id, name, lang, desc, features)
3894#define LANGSTANDARD_ALIAS(id, alias) \
3895 if (KindValue == LangStandard::lang_##id) Diag << alias;
3896#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3897#include "clang/Basic/LangStandards.def"
3905 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3913 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3915 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3916 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3917 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3918 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3919 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3920 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3921 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3922 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
3923 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
3924 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
3928 Diags.
Report(diag::err_drv_invalid_value)
3929 << A->getAsString(Args) << A->getValue();
3932 LangStd = OpenCLLangStd;
3936 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3937 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3945#define LANG_OPTION_WITH_MARSHALLING(...) \
3946 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3947#include "clang/Driver/Options.inc"
3948#undef LANG_OPTION_WITH_MARSHALLING
3950 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3951 StringRef Name = A->getValue();
3952 if (Name ==
"full" || Name ==
"branch") {
3953 Opts.CFProtectionBranch = 1;
3957 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3958 !Args.hasArg(OPT_sycl_std_EQ)) {
3968 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3969 StringRef value =
arg->getValue();
3971 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3974 if (Args.hasArg(OPT_fobjc_gc_only))
3976 else if (Args.hasArg(OPT_fobjc_gc))
3978 else if (Args.hasArg(OPT_fobjc_arc)) {
3979 Opts.ObjCAutoRefCount = 1;
3981 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3988 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3989 Opts.ObjCWeakRuntime = 1;
3995 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3996 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3997 assert(!Opts.ObjCWeak);
3999 Diags.
Report(diag::err_objc_weak_with_gc);
4000 }
else if (!Opts.ObjCWeakRuntime) {
4001 Diags.
Report(diag::err_objc_weak_unsupported);
4005 }
else if (Opts.ObjCAutoRefCount) {
4006 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
4009 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
4010 Opts.ObjCSubscriptingLegacyRuntime =
4014 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
4017 VersionTuple GNUCVer;
4018 bool Invalid = GNUCVer.tryParse(A->getValue());
4019 unsigned Major = GNUCVer.getMajor();
4020 unsigned Minor = GNUCVer.getMinor().value_or(0);
4021 unsigned Patch = GNUCVer.getSubminor().value_or(0);
4022 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
4023 Diags.
Report(diag::err_drv_invalid_value)
4024 << A->getAsString(Args) << A->getValue();
4026 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
4029 if (
T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
4030 Opts.IgnoreXCOFFVisibility = 1;
4032 if (Args.hasArg(OPT_ftrapv)) {
4036 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
4038 else if (Args.hasArg(OPT_fwrapv))
4041 Opts.MSCompatibilityVersion = 0;
4042 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
4044 if (VT.tryParse(A->getValue()))
4045 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
4047 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
4048 VT.getMinor().value_or(0) * 100000 +
4049 VT.getSubminor().value_or(0);
4057 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
4060 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
4063 Args.hasFlag(OPT_fzos_extensions, OPT_fno_zos_extensions,
T.isOSzOS());
4065 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
4066 && Opts.OpenCLVersion == 200);
4068 Opts.ConvergentFunctions = Args.hasArg(OPT_fconvergent_functions) ||
4069 Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
4070 Opts.SYCLIsDevice || Opts.HLSL;
4072 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
4073 if (!Opts.NoBuiltin)
4075 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
4076 if (A->getOption().matches(options::OPT_mlong_double_64))
4077 Opts.LongDoubleSize = 64;
4078 else if (A->getOption().matches(options::OPT_mlong_double_80))
4079 Opts.LongDoubleSize = 80;
4080 else if (A->getOption().matches(options::OPT_mlong_double_128))
4081 Opts.LongDoubleSize = 128;
4083 Opts.LongDoubleSize = 0;
4085 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
4091 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
4093 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4094 << A->getSpelling() <<
"-fdefault-calling-conv";
4096 switch (
T.getArch()) {
4097 case llvm::Triple::x86:
4100 case llvm::Triple::m68k:
4104 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4105 << A->getSpelling() <<
T.getTriple();
4111 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;
4113 bool IsSimdSpecified =
4114 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
4116 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
4118 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
4119 Opts.OpenMPIsTargetDevice =
4120 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);
4121 Opts.OpenMPIRBuilder =
4122 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
4123 bool IsTargetSpecified =
4124 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
4126 Opts.ConvergentFunctions =
4127 Opts.ConvergentFunctions || Opts.OpenMPIsTargetDevice;
4129 if (Opts.OpenMP || Opts.OpenMPSimd) {
4131 Args, OPT_fopenmp_version_EQ,
4132 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))
4133 Opts.OpenMP = Version;
4136 if (!Opts.OpenMPIsTargetDevice) {
4137 switch (
T.getArch()) {
4141 case llvm::Triple::nvptx:
4142 case llvm::Triple::nvptx64:
4143 Diags.
Report(diag::err_drv_omp_host_target_not_supported) <<
T.str();
4151 if ((Opts.OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN())) ||
4152 Opts.OpenCLCPlusPlus) {
4154 Opts.Exceptions = 0;
4155 Opts.CXXExceptions = 0;
4157 if (Opts.OpenMPIsTargetDevice &&
T.isNVPTX()) {
4158 Opts.OpenMPCUDANumSMs =
4160 Opts.OpenMPCUDANumSMs, Diags);
4161 Opts.OpenMPCUDABlocksPerSM =
4163 Opts.OpenMPCUDABlocksPerSM, Diags);
4165 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
4166 Opts.OpenMPCUDAReductionBufNum, Diags);
4171 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
4172 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
4174 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
4175 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
4176 Opts.OpenMPTargetDebug = 1;
4179 if (Opts.OpenMPIsTargetDevice) {
4180 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
4181 Opts.OpenMPTeamSubscription =
true;
4182 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
4183 Opts.OpenMPThreadSubscription =
true;
4187 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
4188 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
4189 auto getArchPtrSize = [](
const llvm::Triple &
T) {
4190 if (
T.isArch16Bit())
4192 if (
T.isArch32Bit())
4194 assert(
T.isArch64Bit() &&
"Expected 64-bit architecture");
4198 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
4199 llvm::Triple TT(A->getValue(i));
4201 if (TT.getArch() == llvm::Triple::UnknownArch ||
4202 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
4203 TT.getArch() == llvm::Triple::systemz ||
4204 TT.getArch() == llvm::Triple::nvptx ||
4205 TT.getArch() == llvm::Triple::nvptx64 ||
4206 TT.getArch() == llvm::Triple::amdgcn ||
4207 TT.getArch() == llvm::Triple::x86 ||
4208 TT.getArch() == llvm::Triple::x86_64))
4209 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
4210 else if (getArchPtrSize(
T) != getArchPtrSize(TT))
4211 Diags.
Report(diag::err_drv_incompatible_omp_arch)
4212 << A->getValue(i) <<
T.str();
4220 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
4223 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
4228 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&
4229 (
T.isNVPTX() ||
T.isAMDGCN()) &&
4230 Args.hasArg(options::OPT_fopenmp_cuda_mode);
4233 if (Args.hasArg(options::OPT_fopenacc)) {
4234 Opts.OpenACC =
true;
4236 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override))
4243 Opts.Optimize = Opt != 0;
4244 Opts.OptimizeSize = OptSize != 0;
4249 Opts.NoInlineDefine = !Opts.Optimize;
4250 if (Arg *InlineArg = Args.getLastArg(
4251 options::OPT_finline_functions, options::OPT_finline_hint_functions,
4252 options::OPT_fno_inline_functions, options::OPT_fno_inline))
4253 if (InlineArg->getOption().matches(options::OPT_fno_inline))
4254 Opts.NoInlineDefine =
true;
4256 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
4257 StringRef Val = A->getValue();
4260 else if (Val ==
"on")
4262 else if (Val ==
"off")
4264 else if (Val ==
"fast-honor-pragmas")
4267 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
4271 Args.getLastArg(OPT_fsanitize_undefined_ignore_overflow_pattern_EQ)) {
4272 for (
int i = 0, n = A->getNumValues(); i != n; ++i) {
4274 llvm::StringSwitch<unsigned>(A->getValue(i))
4287 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
4288 std::vector<std::string> systemIgnorelists =
4289 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
4291 systemIgnorelists.begin(),
4292 systemIgnorelists.end());
4294 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
4297 StringRef Ver = A->getValue();
4298 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
4299 unsigned Major, Minor = 0;
4303 if (!VerParts.first.starts_with(
"0") &&
4304 !VerParts.first.getAsInteger(10, Major) && 3 <= Major &&
4305 Major <= CLANG_VERSION_MAJOR &&
4307 ? VerParts.second.size() == 1 &&
4308 !VerParts.second.getAsInteger(10, Minor)
4309 : VerParts.first.size() == Ver.size() || VerParts.second ==
"0")) {
4311 if (Major == 3 && Minor <= 8)
4313 else if (Major <= 4)
4315 else if (Major <= 6)
4317 else if (Major <= 7)
4319 else if (Major <= 9)
4321 else if (Major <= 11)
4323 else if (Major <= 12)
4325 else if (Major <= 14)
4327 else if (Major <= 15)
4329 else if (Major <= 17)
4331 else if (Major <= 18)
4333 }
else if (Ver !=
"latest") {
4334 Diags.
Report(diag::err_drv_invalid_value)
4335 << A->getAsString(Args) << A->getValue();
4339 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4340 StringRef SignScope = A->getValue();
4342 if (SignScope.equals_insensitive(
"none"))
4343 Opts.setSignReturnAddressScope(
4345 else if (SignScope.equals_insensitive(
"all"))
4346 Opts.setSignReturnAddressScope(
4348 else if (SignScope.equals_insensitive(
"non-leaf"))
4349 Opts.setSignReturnAddressScope(
4352 Diags.
Report(diag::err_drv_invalid_value)
4353 << A->getAsString(Args) << SignScope;
4355 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4356 StringRef SignKey = A->getValue();
4357 if (!SignScope.empty() && !SignKey.empty()) {
4358 if (SignKey ==
"a_key")
4359 Opts.setSignReturnAddressKey(
4361 else if (SignKey ==
"b_key")
4362 Opts.setSignReturnAddressKey(
4365 Diags.
Report(diag::err_drv_invalid_value)
4366 << A->getAsString(Args) << SignKey;
4372 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4379 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI <<
T.str();
4385 Opts.RelativeCXXABIVTables =
4386 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4387 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4391 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);
4392 Opts.OmitVTableRTTI =
4393 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
4394 options::OPT_fno_experimental_omit_vtable_rtti,
false);
4395 if (Opts.OmitVTableRTTI && HasRTTI)
4396 Diags.
Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
4398 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4399 auto Split = StringRef(A).split(
'=');
4401 {std::string(
Split.first), std::string(
Split.second)});
4405 !Args.getLastArg(OPT_fno_file_reproducible) &&
4406 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4407 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4408 Args.getLastArg(OPT_ffile_reproducible));
4411 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4413 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4414 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4417 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4418 std::ifstream SeedFile(A->getValue(0));
4420 if (!SeedFile.is_open())
4421 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4427 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4434 if (
T.isDXIL() ||
T.isSPIRVLogical()) {
4436 enum { OS, Environment };
4438 int ExpectedOS =
T.isSPIRVLogical() ? VulkanEnv : ShaderModel;
4440 if (
T.getOSName().empty()) {
4441 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4442 << ExpectedOS << OS <<
T.str();
4443 }
else if (
T.getEnvironmentName().empty()) {
4444 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4446 }
else if (!
T.isShaderStageEnvironment()) {
4447 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4452 if (!
T.isShaderModelOS() ||
T.getOSVersion() == VersionTuple(0)) {
4453 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4454 << ShaderModel <<
T.getOSName() <<
T.str();
4459 if (Args.getLastArg(OPT_fnative_half_type)) {
4462 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018 &&
4463 T.getOSVersion() >= VersionTuple(6, 2)))
4464 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4465 <<
"-enable-16bit-types" <<
true <<
Std.getName()
4466 <<
T.getOSVersion().getAsString();
4468 }
else if (
T.isSPIRVLogical()) {
4469 if (!
T.isVulkanOS() ||
T.getVulkanVersion() == VersionTuple(0)) {
4470 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4471 << VulkanEnv <<
T.getOSName() <<
T.str();
4473 if (Args.getLastArg(OPT_fnative_half_type)) {
4476 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018))
4477 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4478 <<
"-fnative-half-type" <<
false <<
Std.getName();
4481 llvm_unreachable(
"expected DXIL or SPIR-V target");
4484 Diags.
Report(diag::err_drv_hlsl_unsupported_target) <<
T.str();
4534 llvm_unreachable(
"invalid frontend action");
4544#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4545 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4546#include "clang/Driver/Options.inc"
4547#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4550 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);
4553 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl,
D);
4560 for (
const auto &M : Opts.
Macros) {
4563 if (M.first ==
"__CET__=1" && !M.second &&
4564 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4566 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4567 !CodeGenOpts.CFProtectionBranch)
4569 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4570 CodeGenOpts.CFProtectionBranch)
4573 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);
4576 for (
const auto &I : Opts.
Includes) {
4579 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4580 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4585 if (LangOpts.HLSL && I ==
"hlsl.h")
4595 GenerateArg(Consumer, OPT_remap_file, RF.first +
";" + RF.second);
4601 GenerateArg(Consumer, OPT_fdefine_target_os_macros);
4604 GenerateArg(Consumer, OPT_embed_dir_EQ, EmbedEntry);
4618#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4619 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4620#include "clang/Driver/Options.inc"
4621#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4623 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4624 Args.hasArg(OPT_pch_through_hdrstop_use);
4626 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4629 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4630 StringRef
Value(A->getValue());
4631 size_t Comma =
Value.find(
',');
4633 unsigned EndOfLine = 0;
4635 if (Comma == StringRef::npos ||
4636 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4637 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4638 Diags.
Report(diag::err_drv_preamble_format);
4646 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4647 StringRef Name = A->getValue();
4648 if (Name ==
"branch")
4650 else if (Name ==
"return")
4652 else if (Name ==
"full")
4657 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4658 if (A->getOption().matches(OPT_D))
4665 for (
const auto *A : Args.filtered(OPT_include))
4666 Opts.
Includes.emplace_back(A->getValue());
4668 for (
const auto *A : Args.filtered(OPT_chain_include))
4671 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4672 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4674 if (Split.second.empty()) {
4675 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4682 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4683 StringRef Epoch = A->getValue();
4687 const uint64_t MaxTimestamp =
4688 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4690 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4691 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4692 << Epoch << MaxTimestamp;
4698 for (
const auto *A : Args.filtered(OPT_embed_dir_EQ)) {
4699 StringRef Val = A->getValue();
4710 Args.hasFlag(OPT_fdefine_target_os_macros,
4722#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4723 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4724#include "clang/Driver/Options.inc"
4725#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4743#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4744 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4745#include "clang/Driver/Options.inc"
4746#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4749 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4758#define TARGET_OPTION_WITH_MARSHALLING(...) \
4759 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4760#include "clang/Driver/Options.inc"
4761#undef TARGET_OPTION_WITH_MARSHALLING
4767 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,
4777#define TARGET_OPTION_WITH_MARSHALLING(...) \
4778 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4779#include "clang/Driver/Options.inc"
4780#undef TARGET_OPTION_WITH_MARSHALLING
4782 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4783 llvm::VersionTuple Version;
4784 if (Version.tryParse(A->getValue()))
4785 Diags.
Report(diag::err_drv_invalid_value)
4786 << A->getAsString(Args) << A->getValue();
4791 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4792 llvm::VersionTuple Version;
4793 if (Version.tryParse(A->getValue()))
4794 Diags.
Report(diag::err_drv_invalid_value)
4795 << A->getAsString(Args) << A->getValue();
4803bool CompilerInvocation::CreateFromArgsImpl(
4811 unsigned MissingArgIndex, MissingArgCount;
4812 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4813 MissingArgCount, VisibilityMask);
4817 if (MissingArgCount)
4818 Diags.
Report(diag::err_drv_missing_argument)
4819 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4822 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4823 auto ArgString = A->getAsString(Args);
4824 std::string Nearest;
4825 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)
4826 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4828 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4829 << ArgString << Nearest;
4878 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4879 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4880 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4881 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4894 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4900 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4914 Diags, llvm::vfs::getRealFileSystem());
4928 const char *Argv0) {
4934 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4938 Args.push_back(
"-cc1");
4941 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4946 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;
4959#define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
4960#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4961 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
4962#define BENIGN_LANGOPT(Name, Bits, Default, Description)
4963#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4964#include "clang/Basic/LangOptions.def"
4969 HBuilder.addRange(
getLangOpts().CommentOpts.BlockCommandNames);
4986 StringRef MacroDef = Macro.first;
4988 llvm::CachedHashString(MacroDef.split(
'=').first)))
4992 HBuilder.add(Macro);
5008#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
5009#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5010 HBuilder.add(diagOpts.get##Name());
5011#include "clang/Basic/DiagnosticOptions.def"
5021 ext->hashExtension(HBuilder);
5028 HBuilder.add(*Minor);
5029 if (
auto Subminor =
APINotesOpts.SwiftVersion.getSubminor())
5030 HBuilder.add(*Subminor);
5032 HBuilder.add(*Build);
5042#define DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
5043#define VALUE_DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
5044#define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
5045 HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
5046#define BENIGN_DEBUGOPT(Name, Bits, Default)
5047#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
5048#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
5049#include "clang/Basic/DebugOptions.def"
5056 if (!SanHash.
empty())
5057 HBuilder.add(SanHash.
Mask);
5059 llvm::MD5::MD5Result
Result;
5060 HBuilder.getHasher().final(
Result);
5062 return toString(llvm::APInt(64, Hash), 36,
false);
5090 std::vector<std::string> Args{
"-cc1"};
5092 [&Args](
const Twine &Arg) { Args.push_back(Arg.str()); });
5118 llvm::vfs::getRealFileSystem());
5126 Diags, std::move(BaseFS));
5132 if (VFSOverlayFiles.empty())
5137 for (
const auto &
File : VFSOverlayFiles) {
5138 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
5141 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
5146 std::move(Buffer.get()),
nullptr,
File,
5149 Diags.
Report(diag::err_invalid_vfs_overlay) <<
File;