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());
196T &ensureOwned(std::shared_ptr<T> &Storage) {
197 if (Storage.use_count() > 1)
198 Storage = std::make_shared<T>(*Storage);
204 if (Storage.useCount() > 1)
205 Storage = llvm::makeIntrusiveRefCnt<T>(*Storage);
223 return ensureOwned(
HSOpts);
227 return ensureOwned(
PPOpts);
247 return ensureOwned(
FSOpts);
269#define SIMPLE_ENUM_VALUE_TABLE
270#include "clang/Driver/Options.inc"
271#undef SIMPLE_ENUM_VALUE_TABLE
277 if (Args.hasArg(Opt))
286 if (Args.hasArg(Opt))
296 const Twine &Spelling, Option::OptionClass,
302 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
306 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
308 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
310 if (Args.hasArg(Opt))
317 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
323 OptSpecifier OtherOpt) {
324 return [
Value, OtherValue,
325 OtherOpt](OptSpecifier Opt,
unsigned,
const ArgList &Args,
327 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
328 return A->getOption().matches(Opt) ?
Value : OtherValue;
336 Option::OptionClass,
unsigned,
bool KeyPath) {
337 if (KeyPath ==
Value)
343 const Twine &Spelling,
344 Option::OptionClass OptClass,
unsigned,
345 const Twine &
Value) {
347 case Option::SeparateClass:
348 case Option::JoinedOrSeparateClass:
349 case Option::JoinedAndSeparateClass:
353 case Option::JoinedClass:
354 case Option::CommaJoinedClass:
355 Consumer(Spelling +
Value);
358 llvm_unreachable(
"Cannot denormalize an option with option class "
359 "incompatible with string denormalization.");
365 Option::OptionClass OptClass,
unsigned TableIndex,
370static std::optional<SimpleEnumValue>
372 for (
int I = 0, E = Table.Size; I != E; ++I)
373 if (Name == Table.Table[I].Name)
374 return Table.Table[I];
379static std::optional<SimpleEnumValue>
381 for (
int I = 0, E = Table.Size; I != E; ++I)
383 return Table.Table[I];
392 assert(TableIndex < SimpleEnumValueTablesSize);
393 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
395 auto *Arg = Args.getLastArg(Opt);
399 StringRef ArgValue = Arg->getValue();
401 return MaybeEnumVal->Value;
403 Diags.
Report(diag::err_drv_invalid_value)
404 << Arg->getAsString(Args) << ArgValue;
409 const Twine &Spelling,
410 Option::OptionClass OptClass,
411 unsigned TableIndex,
unsigned Value) {
412 assert(TableIndex < SimpleEnumValueTablesSize);
413 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
418 llvm_unreachable(
"The simple enum value was not correctly defined in "
419 "the tablegen option description");
425 const Twine &Spelling,
426 Option::OptionClass OptClass,
427 unsigned TableIndex, T
Value) {
429 static_cast<unsigned>(
Value));
436 auto *Arg = Args.getLastArg(Opt);
439 return std::string(Arg->getValue());
442template <
typename IntTy>
446 auto *Arg = Args.getLastArg(Opt);
450 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
451 Diags.
Report(diag::err_drv_invalid_int_value)
452 << Arg->getAsString(Args) << Arg->getValue();
458static std::optional<std::vector<std::string>>
461 return Args.getAllArgValues(Opt);
465 const Twine &Spelling,
466 Option::OptionClass OptClass,
468 const std::vector<std::string> &Values) {
470 case Option::CommaJoinedClass: {
471 std::string CommaJoinedValue;
472 if (!Values.empty()) {
473 CommaJoinedValue.append(Values.front());
474 for (
const std::string &
Value : llvm::drop_begin(Values, 1)) {
475 CommaJoinedValue.append(
",");
476 CommaJoinedValue.append(
Value);
480 TableIndex, CommaJoinedValue);
483 case Option::JoinedClass:
484 case Option::SeparateClass:
485 case Option::JoinedOrSeparateClass:
486 for (
const std::string &
Value : Values)
490 llvm_unreachable(
"Cannot denormalize an option with option class "
491 "incompatible with string vector denormalization.");
499 auto *Arg = Args.getLastArg(Opt);
502 return llvm::Triple::normalize(Arg->getValue());
505template <
typename T,
typename U>
507 return static_cast<T
>(
Value);
511 return KeyPath |
Value;
518template <
typename T,
typename U, U Value>
523#define PARSE_OPTION_WITH_MARSHALLING( \
524 ARGS, DIAGS, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, \
525 FLAGS, VISIBILITY, PARAM, HELPTEXT, METAVAR, VALUES, SHOULD_PARSE, \
526 ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, \
527 NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
528 if ((VISIBILITY)&options::CC1Option) { \
529 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
531 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
533 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
535 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
540#define GENERATE_OPTION_WITH_MARSHALLING( \
541 CONSUMER, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, \
542 VISIBILITY, PARAM, HELPTEXT, METAVAR, VALUES, SHOULD_PARSE, ALWAYS_EMIT, \
543 KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \
544 DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
545 if ((VISIBILITY)&options::CC1Option) { \
546 [&](const auto &Extracted) { \
549 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
550 : (DEFAULT_VALUE)))) \
551 DENORMALIZER(CONSUMER, SPELLING, Option::KIND##Class, TABLE_INDEX, \
553 }(EXTRACTOR(KEYPATH)); \
567 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
568 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
569 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
570 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
573 CodeGenOpts.ClearASTBeforeBackend =
false;
575 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
576 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
579 llvm::Triple T(TargetOpts.
Triple);
580 llvm::Triple::ArchType Arch = T.getArch();
585 if (LangOpts.getExceptionHandling() !=
587 T.isWindowsMSVCEnvironment())
588 Diags.
Report(diag::err_fe_invalid_exception_model)
589 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str();
591 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
592 Diags.
Report(diag::warn_c_kext);
594 if (LangOpts.NewAlignOverride &&
595 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
596 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
597 Diags.
Report(diag::err_fe_invalid_alignment)
598 << A->getAsString(Args) << A->getValue();
599 LangOpts.NewAlignOverride = 0;
603 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
604 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
607 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
608 Diags.
Report(diag::err_drv_argument_not_allowed_with)
611 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
612 Diags.
Report(diag::err_drv_argument_not_allowed_with)
615 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
616 Diags.
Report(diag::warn_ignored_hip_only_option)
617 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
619 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
620 Diags.
Report(diag::warn_ignored_hip_only_option)
621 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
630 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
631 if (LangOpts.ApproxFunc)
632 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
633 if (LangOpts.AllowFPReassoc)
634 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
635 if (LangOpts.AllowRecip)
636 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
642 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
644 Diags.
Report(diag::warn_option_invalid_ocl_version)
646 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
648 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
649 auto DefaultCC = LangOpts.getDefaultCallingConv();
653 Arch != llvm::Triple::x86;
659 Diags.
Report(diag::err_drv_argument_not_allowed_with)
660 << A->getSpelling() << T.getTriple();
672 unsigned DefaultOpt = 0;
675 !Args.hasArg(OPT_cl_opt_disable))
678 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
679 if (A->getOption().matches(options::OPT_O0))
682 if (A->getOption().matches(options::OPT_Ofast))
685 assert(A->getOption().matches(options::OPT_O));
687 StringRef S(A->getValue());
688 if (S ==
"s" || S ==
"z")
701 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
702 if (A->getOption().matches(options::OPT_O)) {
703 switch (A->getValue()[0]) {
717 llvm::opt::OptSpecifier OptSpecifier) {
720 Option::OptionClass::FlagClass, 0);
724 llvm::opt::OptSpecifier OptSpecifier,
725 const Twine &
Value) {
763 bool CheckAgainstOriginalInvocation =
false,
764 bool ForceRoundTrip =
false) {
766 bool DoRoundTripDefault =
true;
768 bool DoRoundTripDefault =
false;
771 bool DoRoundTrip = DoRoundTripDefault;
772 if (ForceRoundTrip) {
775 for (
const auto *Arg : CommandLineArgs) {
776 if (Arg == StringRef(
"-round-trip-args"))
778 if (Arg == StringRef(
"-no-round-trip-args"))
786 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
791 llvm::raw_string_ostream OS(Buffer);
792 for (
const char *Arg : Args) {
793 llvm::sys::printArg(OS, Arg,
true);
806 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
813 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
819 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
820 Diags.
Report(diag::note_cc1_round_trip_original)
821 << SerializeArgs(CommandLineArgs);
826 llvm::BumpPtrAllocator Alloc;
827 llvm::StringSaver StringPool(Alloc);
828 auto SA = [&StringPool](
const Twine &Arg) {
829 return StringPool.save(Arg).data();
836 Generate(DummyInvocation, GeneratedArgs, SA);
842 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
847 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
848 Diags.
Report(diag::note_cc1_round_trip_generated)
849 << 1 << SerializeArgs(GeneratedArgs);
854 if (CheckAgainstOriginalInvocation)
856 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
860 Generate(RealInvocation, ComparisonArgs, SA);
865 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
866 [](
const char *AElem,
const char *BElem) {
867 return StringRef(AElem) == StringRef(BElem);
874 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
875 Diags.
Report(diag::err_cc1_round_trip_mismatch);
876 Diags.
Report(diag::note_cc1_round_trip_generated)
877 << 1 << SerializeArgs(GeneratedArgs);
878 Diags.
Report(diag::note_cc1_round_trip_generated)
879 << 2 << SerializeArgs(ComparisonArgs);
883 Diags.
Report(diag::remark_cc1_round_trip_generated)
884 << 1 << SerializeArgs(GeneratedArgs);
885 Diags.
Report(diag::remark_cc1_round_trip_generated)
886 << 2 << SerializeArgs(ComparisonArgs);
898 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
902 Args.push_back(
"-cc1");
905 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
910 OptSpecifier GroupWithValue,
911 std::vector<std::string> &Diagnostics) {
912 for (
auto *A : Args.filtered(Group)) {
913 if (A->getOption().getKind() == Option::FlagClass) {
916 Diagnostics.push_back(
917 std::string(A->getOption().getName().drop_front(1)));
918 }
else if (A->getOption().matches(GroupWithValue)) {
921 Diagnostics.push_back(
922 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
925 Diagnostics.push_back(A->getValue());
936 std::vector<std::string> &Funcs) {
937 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
939 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
946#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
947 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
948#include "clang/Driver/Options.inc"
949#undef ANALYZER_OPTION_WITH_MARSHALLING
953#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
955 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \
957#include "clang/StaticAnalyzer/Core/Analyses.def"
959 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
965#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
967 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \
969#include "clang/StaticAnalyzer/Core/Analyses.def"
971 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
977#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
979 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \
981#include "clang/StaticAnalyzer/Core/Analyses.def"
983 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
989#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
991 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \
993#include "clang/StaticAnalyzer/Core/Analyses.def"
995 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
1001 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
1010 for (
const auto &
C : Opts.
Config)
1011 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
1012 llvm::sort(SortedConfigOpts, llvm::less_first());
1014 for (
const auto &[Key,
Value] : SortedConfigOpts) {
1017 auto Entry = ConfigOpts.
Config.find(Key);
1018 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
1033#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
1034 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1035#include "clang/Driver/Options.inc"
1036#undef ANALYZER_OPTION_WITH_MARSHALLING
1038 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
1039 StringRef Name = A->getValue();
1041#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1042 .Case(CMDFLAG, NAME##Model)
1043#include "clang/StaticAnalyzer/Core/Analyses.def"
1046 Diags.
Report(diag::err_drv_invalid_value)
1047 << A->getAsString(Args) << Name;
1050 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
1051 Diags.
Report(diag::err_analyzer_not_built_with_z3);
1058 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
1059 StringRef Name = A->getValue();
1061#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1062 .Case(CMDFLAG, PD_##NAME)
1063#include "clang/StaticAnalyzer/Core/Analyses.def"
1066 Diags.
Report(diag::err_drv_invalid_value)
1067 << A->getAsString(Args) << Name;
1073 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
1074 StringRef Name = A->getValue();
1076#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1077 .Case(CMDFLAG, NAME)
1078#include "clang/StaticAnalyzer/Core/Analyses.def"
1081 Diags.
Report(diag::err_drv_invalid_value)
1082 << A->getAsString(Args) << Name;
1088 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
1089 StringRef Name = A->getValue();
1091#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1092 .Case(CMDFLAG, NAME)
1093#include "clang/StaticAnalyzer/Core/Analyses.def"
1096 Diags.
Report(diag::err_drv_invalid_value)
1097 << A->getAsString(Args) << Name;
1105 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1107 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1110 StringRef CheckerAndPackageList = A->getValue();
1112 CheckerAndPackageList.split(CheckersAndPackages,
",");
1113 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1119 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1123 StringRef configList = A->getValue();
1125 configList.split(configVals,
",");
1126 for (
const auto &configVal : configVals) {
1128 std::tie(key, val) = configVal.split(
"=");
1131 diag::err_analyzer_config_no_value) << configVal;
1134 if (val.contains(
'=')) {
1136 diag::err_analyzer_config_multiple_values)
1145 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1150 Opts.
Config[key] = std::string(val);
1160 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1163 os << Args.getArgString(i);
1171 StringRef OptionName, StringRef DefaultVal) {
1172 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1177 StringRef &OptionField, StringRef Name,
1178 StringRef DefaultVal) {
1187 bool &OptionField, StringRef Name,
bool DefaultVal) {
1188 auto PossiblyInvalidVal =
1189 llvm::StringSwitch<std::optional<bool>>(
1192 .Case(
"false",
false)
1193 .Default(std::nullopt);
1195 if (!PossiblyInvalidVal) {
1197 Diags->
Report(diag::err_analyzer_config_invalid_input)
1198 << Name <<
"a boolean";
1200 OptionField = DefaultVal;
1202 OptionField = *PossiblyInvalidVal;
1207 unsigned &OptionField, StringRef Name,
1208 unsigned DefaultVal) {
1210 OptionField = DefaultVal;
1211 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1212 .getAsInteger(0, OptionField);
1213 if (Diags && HasFailed)
1214 Diags->
Report(diag::err_analyzer_config_invalid_input)
1215 << Name <<
"an unsigned";
1223#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1224 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1225#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1226#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1228 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1229 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1231#define ANALYZER_OPTION(...)
1232#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1233 SHALLOW_VAL, DEEP_VAL) \
1234 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1235 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1236#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1243 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1244 std::vector<StringRef> Checkers =
1246 std::vector<StringRef> Packages =
1250 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1252 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1254 bool IsChecker = CheckerOrPackage.contains(
'.');
1255 bool IsValidName = IsChecker
1256 ? llvm::is_contained(Checkers, CheckerOrPackage)
1257 : llvm::is_contained(Packages, CheckerOrPackage);
1260 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1261 << CheckerOrPackage;
1271 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1272 Diags->
Report(diag::err_analyzer_config_invalid_input)
1273 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1275 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1276 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1279 if (!AnOpts.ModelPath.empty() &&
1280 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1281 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1290 if (
Remark.hasValidPattern()) {
1295 GenerateArg(Consumer, OPT_R_Joined, StringRef(
"no-") + Name);
1304 OptSpecifier OptEQ, StringRef Name) {
1307 auto InitializeResultPattern = [&Diags, &Args, &
Result](
const Arg *A,
1308 StringRef Pattern) {
1309 Result.Pattern = Pattern.str();
1311 std::string RegexError;
1312 Result.Regex = std::make_shared<llvm::Regex>(
Result.Pattern);
1313 if (!
Result.Regex->isValid(RegexError)) {
1314 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1315 << RegexError << A->getAsString(Args);
1322 for (Arg *A : Args) {
1323 if (A->getOption().matches(OPT_R_Joined)) {
1324 StringRef
Value = A->getValue();
1328 else if (
Value ==
"everything")
1330 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1332 else if (
Value ==
"no-everything")
1342 InitializeResultPattern(A,
".*");
1344 }
else if (A->getOption().matches(OptEQ)) {
1346 if (!InitializeResultPattern(A, A->getValue()))
1355 const std::vector<std::string> &Levels,
1358 bool Success =
true;
1359 for (
const auto &Level : Levels) {
1361 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1369 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1377 const std::vector<std::string> &Sanitizers,
1379 for (
const auto &Sanitizer : Sanitizers) {
1382 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1398 llvm::SplitString(Bundle, BundleParts,
",");
1399 for (
const auto &B : BundleParts) {
1403 D.
Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1417 llvm::raw_string_ostream OS(Buffer);
1418 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1424 const Twine &ProfileName,
1425 llvm::vfs::FileSystem &FS,
1427 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);
1428 if (
auto E = ReaderOrErr.takeError()) {
1430 "Error in reading profile %0: %1");
1431 llvm::handleAllErrors(std::move(E), [&](
const llvm::ErrorInfoBase &EI) {
1432 Diags.
Report(DiagID) << ProfileName.str() << EI.message();
1436 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1437 std::move(ReaderOrErr.get());
1441 if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1442 if (PGOReader->hasCSIRLevelProfile())
1450void CompilerInvocationBase::GenerateCodeGenArgs(
const CodeGenOptions &Opts,
1452 const llvm::Triple &T,
1453 const std::string &OutputFile,
1457 if (Opts.OptimizationLevel == 0)
1460 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));
1462#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1463 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
1464#include "clang/Driver/Options.inc"
1465#undef CODEGEN_OPTION_WITH_MARSHALLING
1467 if (Opts.OptimizationLevel > 0) {
1471 GenerateArg(Consumer, OPT_finline_hint_functions);
1476 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1477 GenerateArg(Consumer, OPT_fdirect_access_external_data);
1478 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1479 GenerateArg(Consumer, OPT_fno_direct_access_external_data);
1481 std::optional<StringRef> DebugInfoVal;
1482 switch (Opts.DebugInfo) {
1483 case llvm::codegenoptions::DebugLineTablesOnly:
1484 DebugInfoVal =
"line-tables-only";
1486 case llvm::codegenoptions::DebugDirectivesOnly:
1487 DebugInfoVal =
"line-directives-only";
1489 case llvm::codegenoptions::DebugInfoConstructor:
1490 DebugInfoVal =
"constructor";
1492 case llvm::codegenoptions::LimitedDebugInfo:
1493 DebugInfoVal =
"limited";
1495 case llvm::codegenoptions::FullDebugInfo:
1496 DebugInfoVal =
"standalone";
1498 case llvm::codegenoptions::UnusedTypeInfo:
1499 DebugInfoVal =
"unused-types";
1501 case llvm::codegenoptions::NoDebugInfo:
1502 DebugInfoVal = std::nullopt;
1504 case llvm::codegenoptions::LocTrackingOnly:
1505 DebugInfoVal = std::nullopt;
1509 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
1513 Prefix.first +
"=" + Prefix.second);
1516 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
1517 Prefix.first +
"=" + Prefix.second);
1519 if (Opts.NewStructPathTBAA)
1522 if (Opts.OptimizeSize == 1)
1524 else if (Opts.OptimizeSize == 2)
1532 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1534 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1540 if (Opts.DebugNameTable ==
1541 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1543 else if (Opts.DebugNameTable ==
1544 static_cast<unsigned>(
1545 llvm::DICompileUnit::DebugNameTableKind::Default))
1548 auto TNK = Opts.getDebugSimpleTemplateNames();
1549 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1550 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1551 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"simple");
1552 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1553 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"mangled");
1558 if (Opts.TimePasses) {
1559 if (Opts.TimePassesPerRun)
1560 GenerateArg(Consumer, OPT_ftime_report_EQ,
"per-pass-run");
1565 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1568 if (Opts.PrepareForThinLTO)
1577 StringRef MemProfileBasename(
"memprof.profraw");
1598 std::string InstrBundle =
1600 if (!InstrBundle.empty())
1601 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);
1604 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1605 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"full");
1606 else if (Opts.CFProtectionReturn)
1607 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"return");
1608 else if (Opts.CFProtectionBranch)
1609 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"branch");
1611 if (Opts.FunctionReturnThunks)
1612 GenerateArg(Consumer, OPT_mfunction_return_EQ,
"thunk-extern");
1615 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1616 F.PropagateAttrs && F.Internalize;
1618 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1622 if (Opts.EmulatedTLS)
1630 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,
1635 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1639 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1643 if (Opts.EnableAIXExtendedAltivecABI)
1646 if (Opts.XCOFFReadOnlyPointers)
1664 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,
1669 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,
1673 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);
1676 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);
1678 if (!Opts.EmitVersionIdentMetadata)
1681 switch (Opts.FiniteLoops) {
1693bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1696 const llvm::Triple &T,
1697 const std::string &OutputFile,
1703 unsigned MaxOptLevel = 3;
1704 if (OptimizationLevel > MaxOptLevel) {
1707 Diags.
Report(diag::warn_drv_optimization_value)
1708 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1709 OptimizationLevel = MaxOptLevel;
1711 Opts.OptimizationLevel = OptimizationLevel;
1720#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1721 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1722#include "clang/Driver/Options.inc"
1723#undef CODEGEN_OPTION_WITH_MARSHALLING
1727 if (Opts.OptimizationLevel == 0) {
1729 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1730 options::OPT_finline_hint_functions,
1731 options::OPT_fno_inline_functions,
1732 options::OPT_fno_inline)) {
1735 if (A->getOption().matches(options::OPT_finline_functions))
1737 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1747 Opts.DirectAccessExternalData =
1748 Args.hasArg(OPT_fdirect_access_external_data) ||
1749 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1752 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1754 llvm::StringSwitch<unsigned>(A->getValue())
1755 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1756 .Case(
"line-directives-only",
1757 llvm::codegenoptions::DebugDirectivesOnly)
1758 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1759 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1760 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1761 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1764 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1767 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1773 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1774 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1775 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1776 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1777 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1778 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1779 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1782 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1783 auto Split = StringRef(Arg).split(
'=');
1787 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1788 auto Split = StringRef(Arg).split(
'=');
1792 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1793 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1794 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1795 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1798 llvm::is_contained(DebugEntryValueArchs, T.getArch()))
1799 Opts.EmitCallSiteInfo =
true;
1802 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1807 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1808 Args.hasArg(OPT_new_struct_path_tbaa);
1810 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1811 if (Opts.SimplifyLibCalls)
1814 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1815 (Opts.OptimizationLevel > 1));
1817 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1819 Opts.DebugNameTable =
static_cast<unsigned>(
1820 Args.hasArg(OPT_ggnu_pubnames)
1821 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1822 : Args.hasArg(OPT_gpubnames)
1823 ? llvm::DICompileUnit::DebugNameTableKind::Default
1824 : llvm::DICompileUnit::DebugNameTableKind::None);
1825 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1826 StringRef
Value = A->getValue();
1828 Diags.
Report(diag::err_drv_unsupported_option_argument)
1829 << A->getSpelling() << A->getValue();
1830 Opts.setDebugSimpleTemplateNames(
1831 StringRef(A->getValue()) ==
"simple"
1832 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
1833 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
1836 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1837 Opts.TimePasses =
true;
1840 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1841 StringRef Val = A->getValue();
1842 if (Val ==
"per-pass")
1843 Opts.TimePassesPerRun =
false;
1844 else if (Val ==
"per-pass-run")
1845 Opts.TimePassesPerRun =
true;
1847 Diags.
Report(diag::err_drv_invalid_value)
1848 << A->getAsString(Args) << A->getValue();
1852 Opts.PrepareForLTO =
false;
1853 Opts.PrepareForThinLTO =
false;
1854 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1855 Opts.PrepareForLTO =
true;
1856 StringRef S = A->getValue();
1858 Opts.PrepareForThinLTO =
true;
1859 else if (S !=
"full")
1860 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1861 if (Args.hasArg(OPT_funified_lto))
1862 Opts.PrepareForThinLTO =
true;
1864 if (Arg *A = Args.getLastArg(options::OPT_ffat_lto_objects,
1865 options::OPT_fno_fat_lto_objects)) {
1866 if (A->getOption().matches(options::OPT_ffat_lto_objects)) {
1867 if (Arg *Uni = Args.getLastArg(options::OPT_funified_lto,
1868 options::OPT_fno_unified_lto)) {
1869 if (Uni->getOption().matches(options::OPT_fno_unified_lto))
1870 Diags.
Report(diag::err_drv_incompatible_options)
1871 << A->getAsString(Args) <<
"-fno-unified-lto";
1873 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1874 << A->getAsString(Args) <<
"-funified-lto";
1878 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1880 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1881 << A->getAsString(Args) <<
"-x ir";
1883 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1885 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1887 llvm::StringSwitch<std::string>(A->getValue())
1888 .Case(
"obj", OutputFile)
1889 .Default(llvm::sys::path::filename(OutputFile).str());
1892 const char *MemProfileBasename =
"memprof.profraw";
1893 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1895 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1896 llvm::sys::path::append(Path, MemProfileBasename);
1898 }
else if (Args.hasArg(OPT_fmemory_profile))
1903 if (Args.hasArg(OPT_coverage_version_EQ)) {
1904 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1905 if (CoverageVersion.size() != 4) {
1906 Diags.
Report(diag::err_drv_invalid_value)
1907 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1917 for (
const auto &A : Args) {
1919 if (A->getOption().getID() == options::OPT_o ||
1920 A->getOption().getID() == options::OPT_INPUT ||
1921 A->getOption().getID() == options::OPT_x ||
1922 A->getOption().getID() == options::OPT_fembed_bitcode ||
1923 A->getOption().matches(options::OPT_W_Group))
1926 A->render(Args, ASL);
1927 for (
const auto &arg : ASL) {
1928 StringRef ArgStr(arg);
1929 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1935 auto XRayInstrBundles =
1936 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1937 if (XRayInstrBundles.empty())
1940 for (
const auto &A : XRayInstrBundles)
1944 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1945 StringRef Name = A->getValue();
1946 if (Name ==
"full") {
1947 Opts.CFProtectionReturn = 1;
1948 Opts.CFProtectionBranch = 1;
1949 }
else if (Name ==
"return")
1950 Opts.CFProtectionReturn = 1;
1951 else if (Name ==
"branch")
1952 Opts.CFProtectionBranch = 1;
1953 else if (Name !=
"none")
1954 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1957 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
1958 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
1959 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
1960 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
1961 .Default(llvm::FunctionReturnThunksKind::Invalid);
1964 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1965 << A->getSpelling() << T.getTriple();
1966 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
1967 Diags.
Report(diag::err_drv_invalid_value)
1968 << A->getAsString(Args) << A->getValue();
1969 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
1970 Args.getLastArgValue(OPT_mcmodel_EQ).equals(
"large"))
1971 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1972 << A->getAsString(Args)
1973 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
1975 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
1979 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1982 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1983 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1992 if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
1994 StringRef Name = A->getValue();
1995 if (Name ==
"local-dynamic")
1996 Diags.
Report(diag::err_aix_unsupported_tls_model) << Name;
2000 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
2001 StringRef Val = A->getValue();
2005 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2008 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
2009 StringRef Val = A->getValue();
2012 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2018 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
2019 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
2023 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2024 << A->getSpelling() << T.str();
2026 const Option &O = A->getOption();
2027 if (O.matches(OPT_fpcc_struct_return) ||
2028 O.matches(OPT_maix_struct_return)) {
2031 assert(O.matches(OPT_freg_struct_return) ||
2032 O.matches(OPT_msvr4_struct_return));
2037 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {
2039 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2040 << A->getSpelling() << T.str();
2050 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,
false))
2051 Diags.
Report(diag::err_roptr_requires_data_sections);
2053 Opts.XCOFFReadOnlyPointers =
true;
2056 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
2057 if (!T.isOSAIX() || T.isPPC32())
2058 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2059 << A->getSpelling() << T.str();
2062 bool NeedLocTracking =
false;
2065 NeedLocTracking =
true;
2067 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
2069 NeedLocTracking =
true;
2072 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
2074 NeedLocTracking =
true;
2084 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
2094 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
2097 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2098 <<
"-fdiagnostics-show-hotness";
2102 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2104 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2107 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2108 <<
"-fdiagnostics-hotness-threshold=";
2114 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2115 <<
"-fdiagnostics-hotness-threshold=";
2120 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2124 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2125 <<
"-fdiagnostics-misexpect-tolerance=";
2131 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2132 <<
"-fdiagnostics-misexpect-tolerance=";
2139 if (UsingSampleProfile)
2140 NeedLocTracking =
true;
2143 NeedLocTracking =
true;
2147 if (NeedLocTracking &&
2148 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2149 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2154 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2157 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2160 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2162 if (Args.hasArg(options::OPT_ffinite_loops))
2164 else if (Args.hasArg(options::OPT_fno_finite_loops))
2167 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2168 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2169 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2170 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2178#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2179 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2180#include "clang/Driver/Options.inc"
2181#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2186 for (
const auto &Dep : Opts.
ExtraDeps) {
2187 switch (Dep.second) {
2200 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);
2209 bool ShowLineMarkers) {
2213#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2214 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2215#include "clang/Driver/Options.inc"
2216#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2218 if (Args.hasArg(OPT_show_includes)) {
2233 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2234 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2235 StringRef Val = A->getValue();
2236 if (!Val.contains(
'='))
2240 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2241 StringRef Val = A->getValue();
2242 if (!Val.contains(
'='))
2249 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2253 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2257 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2258 StringRef Val = A->getValue();
2259 if (!Val.contains(
'='))
2269 Diags.
Report(diag::err_drv_print_header_env_var_combination_cc1)
2270 << Args.getLastArg(OPT_header_include_format_EQ)->getValue()
2271 << Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();
2285 }
ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2286 for (
auto *A : Args) {
2287 const Option &O = A->getOption();
2288 if (O.matches(options::OPT_fcolor_diagnostics)) {
2290 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2292 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2293 StringRef
Value(A->getValue());
2294 if (
Value ==
"always")
2296 else if (
Value ==
"never")
2298 else if (
Value ==
"auto")
2304 llvm::sys::Process::StandardErrHasColors());
2309 bool Success =
true;
2310 for (
const auto &Prefix : VerifyPrefixes) {
2313 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2316 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2318 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2319 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2329#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2330 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2331#include "clang/Driver/Options.inc"
2332#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2341#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2342 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2343#include "clang/Driver/Options.inc"
2344#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2352#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2353 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2354#include "clang/Driver/Options.inc"
2355#undef MIGRATOR_OPTION_WITH_MARSHALLING
2364#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2365 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2366#include "clang/Driver/Options.inc"
2367#undef MIGRATOR_OPTION_WITH_MARSHALLING
2372void CompilerInvocationBase::GenerateDiagnosticArgs(
2374 bool DefaultDiagColor) {
2376#define DIAG_OPTION_WITH_MARSHALLING(...) \
2377 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2378#include "clang/Driver/Options.inc"
2379#undef DIAG_OPTION_WITH_MARSHALLING
2382 GenerateArg(Consumer, OPT_diagnostic_serialized_file,
2385 if (Opts.ShowColors)
2388 if (Opts.VerifyDiagnostics &&
2393 if (Prefix !=
"expected")
2400 GenerateArg(Consumer, OPT_verify_ignore_unexpected);
2403 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"note");
2405 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"remark");
2407 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"warning");
2409 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"error");
2414 if (
Warning ==
"undef-prefix")
2416 Consumer(StringRef(
"-W") +
Warning);
2422 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2423 "pass-analysis",
"no-pass-analysis",
2424 "pass-missed",
"no-pass-missed"};
2425 if (llvm::is_contained(IgnoredRemarks,
Remark))
2428 Consumer(StringRef(
"-R") +
Remark);
2432std::unique_ptr<DiagnosticOptions>
2434 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2435 unsigned MissingArgIndex, MissingArgCount;
2437 Argv.slice(1), MissingArgIndex, MissingArgCount);
2440 if (std::optional<std::string> NoColor =
2441 llvm::sys::Process::GetEnv(
"NO_COLOR");
2442 NoColor && !NoColor->empty()) {
2457 bool DefaultDiagColor) {
2458 std::optional<DiagnosticsEngine> IgnoringDiags;
2462 Diags = &*IgnoringDiags;
2471#define DIAG_OPTION_WITH_MARSHALLING(...) \
2472 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2473#include "clang/Driver/Options.inc"
2474#undef DIAG_OPTION_WITH_MARSHALLING
2476 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2479 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2483 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2485 if (Args.hasArg(OPT_verify))
2490 Opts.VerifyDiagnostics =
false;
2495 "-verify-ignore-unexpected=",
2496 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2497 if (Args.hasArg(OPT_verify_ignore_unexpected))
2499 Opts.setVerifyIgnoreUnexpected(DiagMask);
2501 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2517 std::string &BlockName,
2518 unsigned &MajorVersion,
2519 unsigned &MinorVersion,
2521 std::string &UserInfo) {
2523 Arg.split(Args,
':', 5);
2524 if (Args.size() < 5)
2527 BlockName = std::string(Args[0]);
2528 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2529 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2530 if (Args[3].getAsInteger(2, Hashed))
return true;
2531 if (Args.size() > 4)
2532 UserInfo = std::string(Args[4]);
2541 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2587 OPT_print_dependency_directives_minimized_source},
2594static std::optional<frontend::ActionKind>
2597 if (ActionOpt.second == Opt.getID())
2598 return ActionOpt.first;
2600 return std::nullopt;
2604static std::optional<OptSpecifier>
2607 if (ActionOpt.first == ProgramAction)
2608 return OptSpecifier(ActionOpt.second);
2610 return std::nullopt;
2616#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2617 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2618#include "clang/Driver/Options.inc"
2619#undef FRONTEND_OPTION_WITH_MARSHALLING
2621 std::optional<OptSpecifier> ProgramActionOpt =
2625 std::function<void()> GenerateProgramAction = [&]() {
2629 if (!ProgramActionOpt) {
2632 "Frontend action without option.");
2633 GenerateProgramAction = [&]() {
2640 GenerateProgramAction = [&]() {
2648 llvm_unreachable(
"Default AST dump format.");
2655 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);
2668 GenerateProgramAction = [&]() {
2673 GenerateProgramAction();
2675 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2677 for (
const auto &PluginArg : PluginArgs.second)
2679 Opt.getPrefix() + Opt.getName() + PluginArgs.first,
2680 Opt.getKind(), 0, PluginArg);
2684 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2685 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());
2691 for (
const auto &Plugin : Opts.
Plugins)
2697 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);
2704 GenerateArg(Consumer, OPT_aux_target_feature, Feature);
2710 StringRef HeaderUnit =
"";
2715 HeaderUnit =
"-user";
2718 HeaderUnit =
"-system";
2721 HeaderUnit =
"-header-unit";
2724 StringRef Header = IsHeader ?
"-header" :
"";
2747 Lang =
"objective-c";
2750 Lang =
"objective-c++";
2753 Lang =
"renderscript";
2756 Lang =
"assembler-with-cpp";
2760 "Generating -x argument for unknown language (not precompiled).");
2772 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed);
2776 for (
const auto &Input : Opts.
Inputs)
2777 Consumer(Input.getFile());
2786#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2787 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2788#include "clang/Driver/Options.inc"
2789#undef FRONTEND_OPTION_WITH_MARSHALLING
2792 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2793 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2795 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2798 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2799 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2802 .Default(std::numeric_limits<unsigned>::max());
2804 if (Val != std::numeric_limits<unsigned>::max())
2807 Diags.
Report(diag::err_drv_invalid_value)
2808 << A->getAsString(Args) << A->getValue();
2818 Args.hasArg(OPT_interface_stub_version_EQ)
2819 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2821 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2822 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2823 ArgStr ==
"experimental-tapi-elf-v1") {
2824 std::string ErrorMessage =
2825 "Invalid interface stub format: " + ArgStr.str() +
2827 Diags.
Report(diag::err_drv_invalid_value)
2828 <<
"Must specify a valid interface stub format type, ie: "
2829 "-interface-stub-version=ifs-v1"
2832 }
else if (!ArgStr.startswith(
"ifs-")) {
2833 std::string ErrorMessage =
2834 "Invalid interface stub format: " + ArgStr.str() +
".";
2835 Diags.
Report(diag::err_drv_invalid_value)
2836 <<
"Must specify a valid interface stub format type, ie: "
2837 "-interface-stub-version=ifs-v1"
2846 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2847 Opts.
Plugins.emplace_back(A->getValue(0));
2851 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2852 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2854 for (
const std::string &Arg :
2855 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2856 std::string BlockName;
2857 unsigned MajorVersion;
2858 unsigned MinorVersion;
2860 std::string UserInfo;
2862 MinorVersion, Hashed, UserInfo)) {
2863 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2870 std::make_shared<TestModuleFileExtension>(
2871 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2874 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2878 Diags.
Report(diag::err_drv_invalid_value)
2879 << A->getAsString(Args) << A->getValue();
2882 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2883 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2884 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2886 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2887 StringRef Val = A->getValue();
2888 if (!Val.contains(
'='))
2893 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2896 if (Args.hasArg(OPT_aux_target_cpu))
2897 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
2898 if (Args.hasArg(OPT_aux_target_feature))
2903 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2904 <<
"ARC migration" <<
"ObjC migration";
2908 if (
const Arg *A = Args.getLastArg(OPT_x)) {
2909 StringRef XValue = A->getValue();
2914 bool Preprocessed = XValue.consume_back(
"-cpp-output");
2915 bool ModuleMap = XValue.consume_back(
"-module-map");
2918 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
2924 if (IsHeader || Preprocessed) {
2925 if (XValue.consume_back(
"-header-unit"))
2927 else if (XValue.consume_back(
"-system"))
2929 else if (XValue.consume_back(
"-user"))
2935 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
2939 DashX = llvm::StringSwitch<InputKind>(XValue)
2956 DashX = llvm::StringSwitch<InputKind>(XValue)
2964 DashX = llvm::StringSwitch<InputKind>(XValue)
2967 .Cases(
"ast",
"pcm",
"precompiled-header",
2973 Diags.
Report(diag::err_drv_invalid_value)
2974 << A->getAsString(Args) << A->getValue();
2981 IsHeaderFile =
true;
2982 }
else if (IsHeaderFile)
2989 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
2992 Inputs.push_back(
"-");
2996 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
2998 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
3002 StringRef(Inputs[i]).rsplit(
'.').second);
3011 bool IsSystem =
false;
3020 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
3030 std::string ClangExecutable =
3031 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
3038#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3039 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3040#include "clang/Driver/Options.inc"
3041#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3053 GenerateArg(Consumer, OPT_fprebuilt_module_path, Path);
3056 GenerateArg(Consumer, OPT_fmodules_ignore_macro, Macro.val());
3060 std::optional<bool> IsFramework,
3061 std::optional<bool> IgnoreSysRoot) {
3062 return llvm::is_contained(Groups, Entry.
Group) &&
3063 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
3064 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
3072 std::nullopt,
true);
3074 OptSpecifier Opt = [It, Matches]() {
3083 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
3099 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3106 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3112 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3117 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);
3125 GenerateArg(Consumer, OPT_objc_isystem, It->Path);
3127 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);
3137 ? OPT_internal_isystem
3138 : OPT_internal_externc_isystem;
3142 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3146 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3147 : OPT_no_system_header_prefix;
3157 const std::string &WorkingDir) {
3162#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3163 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3164#include "clang/Driver/Options.inc"
3165#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3167 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3168 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3172 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3173 if (WorkingDir.empty())
3174 llvm::sys::fs::make_absolute(
P);
3176 llvm::sys::fs::make_absolute(WorkingDir,
P);
3178 llvm::sys::path::remove_dots(
P);
3182 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3183 StringRef Val = A->getValue();
3184 if (Val.contains(
'=')) {
3185 auto Split = Val.split(
'=');
3187 std::string(Split.first), std::string(Split.second));
3190 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3193 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3194 StringRef MacroDef = A->getValue();
3196 llvm::CachedHashString(MacroDef.split(
'=').first));
3200 bool IsIndexHeaderMap =
false;
3201 bool IsSysrootSpecified =
3202 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3203 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3204 if (A->getOption().matches(OPT_index_header_map)) {
3206 IsIndexHeaderMap =
true;
3213 bool IsFramework = A->getOption().matches(OPT_F);
3214 std::string Path = A->getValue();
3216 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3218 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3219 llvm::StringRef(A->getValue()).substr(1));
3220 Path = std::string(Buffer.str());
3223 Opts.
AddPath(Path, Group, IsFramework,
3225 IsIndexHeaderMap =
false;
3229 StringRef Prefix =
"";
3230 for (
const auto *A :
3231 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3232 if (A->getOption().matches(OPT_iprefix))
3233 Prefix = A->getValue();
3234 else if (A->getOption().matches(OPT_iwithprefix))
3240 for (
const auto *A : Args.filtered(OPT_idirafter))
3242 for (
const auto *A : Args.filtered(OPT_iquote))
3244 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
3246 !A->getOption().matches(OPT_iwithsysroot));
3247 for (
const auto *A : Args.filtered(OPT_iframework))
3249 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3254 for (
const auto *A : Args.filtered(OPT_c_isystem))
3256 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3258 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3260 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3264 for (
const auto *A :
3265 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3267 if (A->getOption().matches(OPT_internal_externc_isystem))
3269 Opts.
AddPath(A->getValue(), Group,
false,
true);
3273 for (
const auto *A :
3274 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3276 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3278 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3287 GenerateArg(Consumer, OPT_fapinotes_swift_version,
3291 GenerateArg(Consumer, OPT_iapinotes_modules, Path);
3296 if (
const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {
3298 diags.
Report(diag::err_drv_invalid_value)
3299 << A->getAsString(Args) << A->getValue();
3301 for (
const Arg *A : Args.filtered(OPT_iapinotes_modules))
3311 llvm_unreachable(
"should not parse language flags for this input");
3347 llvm_unreachable(
"unexpected input language");
3356 return "Objective-C";
3360 return "Objective-C++";
3364 return "C++ for OpenCL";
3368 return "RenderScript";
3383 llvm_unreachable(
"unknown input language");
3386void CompilerInvocationBase::GenerateLangArgs(
const LangOptions &Opts,
3388 const llvm::Triple &T,
3392 if (Opts.ObjCAutoRefCount)
3394 if (Opts.PICLevel != 0)
3395 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));
3399 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3404 OptSpecifier StdOpt;
3406 case LangStandard::lang_opencl10:
3407 case LangStandard::lang_opencl11:
3408 case LangStandard::lang_opencl12:
3409 case LangStandard::lang_opencl20:
3410 case LangStandard::lang_opencl30:
3411 case LangStandard::lang_openclcpp10:
3412 case LangStandard::lang_openclcpp2021:
3413 StdOpt = OPT_cl_std_EQ;
3416 StdOpt = OPT_std_EQ;
3423 if (Opts.IncludeDefaultHeader)
3424 GenerateArg(Consumer, OPT_finclude_default_header);
3425 if (Opts.DeclareOpenCLBuiltins)
3426 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);
3430#define LANG_OPTION_WITH_MARSHALLING(...) \
3431 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3432#include "clang/Driver/Options.inc"
3433#undef LANG_OPTION_WITH_MARSHALLING
3444 else if (Opts.ObjCAutoRefCount == 1)
3447 if (Opts.ObjCWeakRuntime)
3448 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);
3453 if (Opts.ObjCSubscriptingLegacyRuntime)
3454 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);
3457 if (Opts.GNUCVersion != 0) {
3458 unsigned Major = Opts.GNUCVersion / 100 / 100;
3459 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3460 unsigned Patch = Opts.GNUCVersion % 100;
3462 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch));
3465 if (Opts.IgnoreXCOFFVisibility)
3466 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);
3475 if (Opts.MSCompatibilityVersion != 0) {
3476 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3477 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3478 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3479 GenerateArg(Consumer, OPT_fms_compatibility_version,
3480 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor));
3483 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS()) {
3484 if (!Opts.Trigraphs)
3491 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3494 if (Opts.ConvergentFunctions &&
3495 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice))
3498 if (Opts.NoBuiltin && !Opts.Freestanding)
3501 if (!Opts.NoBuiltin)
3505 if (Opts.LongDoubleSize == 128)
3507 else if (Opts.LongDoubleSize == 64)
3509 else if (Opts.LongDoubleSize == 80)
3516 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3519 if (Opts.OpenMP != 51)
3520 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3522 if (!Opts.OpenMPUseTLS)
3525 if (Opts.OpenMPIsTargetDevice)
3526 GenerateArg(Consumer, OPT_fopenmp_is_target_device);
3528 if (Opts.OpenMPIRBuilder)
3529 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);
3532 if (Opts.OpenMPSimd) {
3535 if (Opts.OpenMP != 51)
3536 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3539 if (Opts.OpenMPThreadSubscription)
3540 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);
3542 if (Opts.OpenMPTeamSubscription)
3543 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);
3545 if (Opts.OpenMPTargetDebug != 0)
3546 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,
3547 Twine(Opts.OpenMPTargetDebug));
3549 if (Opts.OpenMPCUDANumSMs != 0)
3550 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,
3551 Twine(Opts.OpenMPCUDANumSMs));
3553 if (Opts.OpenMPCUDABlocksPerSM != 0)
3554 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3555 Twine(Opts.OpenMPCUDABlocksPerSM));
3557 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3558 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3559 Twine(Opts.OpenMPCUDAReductionBufNum));
3562 std::string Targets;
3563 llvm::raw_string_ostream OS(Targets);
3566 [&OS](
const llvm::Triple &T) { OS << T.str(); },
",");
3567 GenerateArg(Consumer, OPT_fopenmp_targets_EQ, OS.str());
3573 if (Opts.OpenMPCUDAMode)
3593 GenerateArg(Consumer, OPT_ffp_contract,
"fast-honor-pragmas");
3596 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3600 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
3602 switch (Opts.getClangABICompat()) {
3604 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"3.8");
3607 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"4.0");
3610 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"6.0");
3613 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"7.0");
3616 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"9.0");
3619 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"11.0");
3622 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"12.0");
3625 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"14.0");
3628 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"15.0");
3631 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"17.0");
3637 if (Opts.getSignReturnAddressScope() ==
3639 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"all");
3640 else if (Opts.getSignReturnAddressScope() ==
3642 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"non-leaf");
3644 if (Opts.getSignReturnAddressKey() ==
3646 GenerateArg(Consumer, OPT_msign_return_address_key_EQ,
"b_key");
3652 if (Opts.RelativeCXXABIVTables)
3653 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);
3655 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);
3663 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second);
3669bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3671 std::vector<std::string> &Includes,
3680 if (Args.hasArg(OPT_fobjc_arc))
3681 Opts.ObjCAutoRefCount = 1;
3685 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3697 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3700 Diags.
Report(diag::err_drv_invalid_value)
3701 << A->getAsString(Args) << A->getValue();
3703 for (
unsigned KindValue = 0;
3709 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3710 Diag <<
Std.getName() <<
Std.getDescription();
3711 unsigned NumAliases = 0;
3712#define LANGSTANDARD(id, name, lang, desc, features)
3713#define LANGSTANDARD_ALIAS(id, alias) \
3714 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3715#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3716#include "clang/Basic/LangStandards.def"
3718#define LANGSTANDARD(id, name, lang, desc, features)
3719#define LANGSTANDARD_ALIAS(id, alias) \
3720 if (KindValue == LangStandard::lang_##id) Diag << alias;
3721#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3722#include "clang/Basic/LangStandards.def"
3730 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3738 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3740 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3741 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3742 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3743 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3744 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3745 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3746 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3747 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
3748 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
3749 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
3753 Diags.
Report(diag::err_drv_invalid_value)
3754 << A->getAsString(Args) << A->getValue();
3757 LangStd = OpenCLLangStd;
3761 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3762 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3770#define LANG_OPTION_WITH_MARSHALLING(...) \
3771 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3772#include "clang/Driver/Options.inc"
3773#undef LANG_OPTION_WITH_MARSHALLING
3775 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3776 StringRef Name = A->getValue();
3777 if (Name ==
"full" || Name ==
"branch") {
3778 Opts.CFProtectionBranch = 1;
3782 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3783 !Args.hasArg(OPT_sycl_std_EQ)) {
3793 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3794 StringRef value =
arg->getValue();
3796 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3799 if (Args.hasArg(OPT_fobjc_gc_only))
3801 else if (Args.hasArg(OPT_fobjc_gc))
3803 else if (Args.hasArg(OPT_fobjc_arc)) {
3804 Opts.ObjCAutoRefCount = 1;
3806 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3813 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3814 Opts.ObjCWeakRuntime = 1;
3820 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3821 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3822 assert(!Opts.ObjCWeak);
3824 Diags.
Report(diag::err_objc_weak_with_gc);
3825 }
else if (!Opts.ObjCWeakRuntime) {
3826 Diags.
Report(diag::err_objc_weak_unsupported);
3830 }
else if (Opts.ObjCAutoRefCount) {
3831 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3834 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3835 Opts.ObjCSubscriptingLegacyRuntime =
3839 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
3842 VersionTuple GNUCVer;
3843 bool Invalid = GNUCVer.tryParse(A->getValue());
3844 unsigned Major = GNUCVer.getMajor();
3845 unsigned Minor = GNUCVer.getMinor().value_or(0);
3846 unsigned Patch = GNUCVer.getSubminor().value_or(0);
3847 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
3848 Diags.
Report(diag::err_drv_invalid_value)
3849 << A->getAsString(Args) << A->getValue();
3851 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
3854 if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
3855 Opts.IgnoreXCOFFVisibility = 1;
3857 if (Args.hasArg(OPT_ftrapv)) {
3861 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
3863 else if (Args.hasArg(OPT_fwrapv))
3866 Opts.MSCompatibilityVersion = 0;
3867 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
3869 if (VT.tryParse(A->getValue()))
3870 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3872 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
3873 VT.getMinor().value_or(0) * 100000 +
3874 VT.getSubminor().value_or(0);
3882 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS();
3884 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
3886 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
3887 && Opts.OpenCLVersion == 200);
3889 Opts.ConvergentFunctions = Args.hasArg(OPT_fconvergent_functions) ||
3890 Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
3893 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
3894 if (!Opts.NoBuiltin)
3896 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
3897 if (A->getOption().matches(options::OPT_mlong_double_64))
3898 Opts.LongDoubleSize = 64;
3899 else if (A->getOption().matches(options::OPT_mlong_double_80))
3900 Opts.LongDoubleSize = 80;
3901 else if (A->getOption().matches(options::OPT_mlong_double_128))
3902 Opts.LongDoubleSize = 128;
3904 Opts.LongDoubleSize = 0;
3906 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
3912 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3914 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3915 << A->getSpelling() <<
"-fdefault-calling-conv";
3917 switch (T.getArch()) {
3918 case llvm::Triple::x86:
3921 case llvm::Triple::m68k:
3925 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3926 << A->getSpelling() << T.getTriple();
3932 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;
3934 bool IsSimdSpecified =
3935 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
3937 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
3939 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
3940 Opts.OpenMPIsTargetDevice =
3941 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);
3942 Opts.OpenMPIRBuilder =
3943 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
3944 bool IsTargetSpecified =
3945 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
3947 Opts.ConvergentFunctions =
3948 Opts.ConvergentFunctions || Opts.OpenMPIsTargetDevice;
3950 if (Opts.OpenMP || Opts.OpenMPSimd) {
3952 Args, OPT_fopenmp_version_EQ,
3953 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))
3954 Opts.OpenMP = Version;
3957 if (!Opts.OpenMPIsTargetDevice) {
3958 switch (T.getArch()) {
3962 case llvm::Triple::nvptx:
3963 case llvm::Triple::nvptx64:
3964 Diags.
Report(diag::err_drv_omp_host_target_not_supported) << T.str();
3972 if ((Opts.OpenMPIsTargetDevice && (T.isNVPTX() || T.isAMDGCN())) ||
3973 Opts.OpenCLCPlusPlus) {
3975 Opts.Exceptions = 0;
3976 Opts.CXXExceptions = 0;
3978 if (Opts.OpenMPIsTargetDevice && T.isNVPTX()) {
3979 Opts.OpenMPCUDANumSMs =
3981 Opts.OpenMPCUDANumSMs, Diags);
3982 Opts.OpenMPCUDABlocksPerSM =
3984 Opts.OpenMPCUDABlocksPerSM, Diags);
3986 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3987 Opts.OpenMPCUDAReductionBufNum, Diags);
3992 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
3993 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
3995 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
3996 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
3997 Opts.OpenMPTargetDebug = 1;
4000 if (Opts.OpenMPIsTargetDevice) {
4001 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
4002 Opts.OpenMPTeamSubscription =
true;
4003 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
4004 Opts.OpenMPThreadSubscription =
true;
4008 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
4009 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
4010 auto getArchPtrSize = [](
const llvm::Triple &T) {
4011 if (T.isArch16Bit())
4013 if (T.isArch32Bit())
4015 assert(T.isArch64Bit() &&
"Expected 64-bit architecture");
4019 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
4020 llvm::Triple TT(A->getValue(i));
4022 if (TT.getArch() == llvm::Triple::UnknownArch ||
4023 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
4024 TT.getArch() == llvm::Triple::nvptx ||
4025 TT.getArch() == llvm::Triple::nvptx64 ||
4026 TT.getArch() == llvm::Triple::amdgcn ||
4027 TT.getArch() == llvm::Triple::x86 ||
4028 TT.getArch() == llvm::Triple::x86_64))
4029 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
4030 else if (getArchPtrSize(T) != getArchPtrSize(TT))
4031 Diags.
Report(diag::err_drv_incompatible_omp_arch)
4032 << A->getValue(i) << T.str();
4040 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
4043 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
4048 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&
4049 (T.isNVPTX() || T.isAMDGCN()) &&
4050 Args.hasArg(options::OPT_fopenmp_cuda_mode);
4053 if (Args.hasArg(options::OPT_fopenacc)) {
4054 Opts.OpenACC =
true;
4056 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override))
4063 Opts.Optimize = Opt != 0;
4064 Opts.OptimizeSize = OptSize != 0;
4069 Opts.NoInlineDefine = !Opts.Optimize;
4070 if (Arg *InlineArg = Args.getLastArg(
4071 options::OPT_finline_functions, options::OPT_finline_hint_functions,
4072 options::OPT_fno_inline_functions, options::OPT_fno_inline))
4073 if (InlineArg->getOption().matches(options::OPT_fno_inline))
4074 Opts.NoInlineDefine =
true;
4076 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
4077 StringRef Val = A->getValue();
4080 else if (Val ==
"on")
4082 else if (Val ==
"off")
4084 else if (Val ==
"fast-honor-pragmas")
4087 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
4093 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
4094 std::vector<std::string> systemIgnorelists =
4095 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
4097 systemIgnorelists.begin(),
4098 systemIgnorelists.end());
4100 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
4103 StringRef Ver = A->getValue();
4104 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
4105 unsigned Major, Minor = 0;
4109 if (!VerParts.first.startswith(
"0") &&
4110 !VerParts.first.getAsInteger(10, Major) &&
4111 3 <= Major && Major <= CLANG_VERSION_MAJOR &&
4112 (Major == 3 ? VerParts.second.size() == 1 &&
4113 !VerParts.second.getAsInteger(10, Minor)
4114 : VerParts.first.size() == Ver.size() ||
4115 VerParts.second ==
"0")) {
4117 if (Major == 3 && Minor <= 8)
4119 else if (Major <= 4)
4121 else if (Major <= 6)
4123 else if (Major <= 7)
4125 else if (Major <= 9)
4127 else if (Major <= 11)
4129 else if (Major <= 12)
4131 else if (Major <= 14)
4133 else if (Major <= 15)
4135 else if (Major <= 17)
4137 }
else if (Ver !=
"latest") {
4138 Diags.
Report(diag::err_drv_invalid_value)
4139 << A->getAsString(Args) << A->getValue();
4143 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4144 StringRef SignScope = A->getValue();
4146 if (SignScope.equals_insensitive(
"none"))
4147 Opts.setSignReturnAddressScope(
4149 else if (SignScope.equals_insensitive(
"all"))
4150 Opts.setSignReturnAddressScope(
4152 else if (SignScope.equals_insensitive(
"non-leaf"))
4153 Opts.setSignReturnAddressScope(
4156 Diags.
Report(diag::err_drv_invalid_value)
4157 << A->getAsString(Args) << SignScope;
4159 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4160 StringRef SignKey = A->getValue();
4161 if (!SignScope.empty() && !SignKey.empty()) {
4162 if (SignKey.equals_insensitive(
"a_key"))
4163 Opts.setSignReturnAddressKey(
4165 else if (SignKey.equals_insensitive(
"b_key"))
4166 Opts.setSignReturnAddressKey(
4169 Diags.
Report(diag::err_drv_invalid_value)
4170 << A->getAsString(Args) << SignKey;
4176 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4183 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI << T.str();
4189 Opts.RelativeCXXABIVTables =
4190 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4191 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4195 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);
4196 Opts.OmitVTableRTTI =
4197 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
4198 options::OPT_fno_experimental_omit_vtable_rtti,
false);
4199 if (Opts.OmitVTableRTTI && HasRTTI)
4200 Diags.
Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
4202 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4203 auto Split = StringRef(A).split(
'=');
4205 {std::string(
Split.first), std::string(
Split.second)});
4209 !Args.getLastArg(OPT_fno_file_reproducible) &&
4210 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4211 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4212 Args.getLastArg(OPT_ffile_reproducible));
4215 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4217 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4218 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4221 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4222 std::ifstream SeedFile(A->getValue(0));
4224 if (!SeedFile.is_open())
4225 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4231 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4238 if (T.isDXIL() || T.isSPIRVLogical()) {
4240 if (T.getOSName().empty()) {
4241 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4242 << ShaderModel << T.str();
4243 }
else if (!T.isShaderModelOS() || T.getOSVersion() == VersionTuple(0)) {
4244 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4245 << ShaderModel << T.getOSName() << T.str();
4246 }
else if (T.getEnvironmentName().empty()) {
4247 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4249 }
else if (!T.isShaderStageEnvironment()) {
4250 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4251 <<
ShaderStage << T.getEnvironmentName() << T.str();
4254 Diags.
Report(diag::err_drv_hlsl_unsupported_target) << T.str();
4302 llvm_unreachable(
"invalid frontend action");
4312#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4313 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4314#include "clang/Driver/Options.inc"
4315#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4318 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);
4321 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl, D);
4328 for (
const auto &M : Opts.
Macros) {
4331 if (M.first ==
"__CET__=1" && !M.second &&
4332 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4334 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4335 !CodeGenOpts.CFProtectionBranch)
4337 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4338 CodeGenOpts.CFProtectionBranch)
4341 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);
4344 for (
const auto &I : Opts.
Includes) {
4347 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4348 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4353 if (LangOpts.HLSL && I ==
"hlsl.h")
4363 GenerateArg(Consumer, OPT_remap_file, RF.first +
";" + RF.second);
4380#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4381 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4382#include "clang/Driver/Options.inc"
4383#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4385 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4386 Args.hasArg(OPT_pch_through_hdrstop_use);
4388 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4391 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4392 StringRef
Value(A->getValue());
4393 size_t Comma =
Value.find(
',');
4395 unsigned EndOfLine = 0;
4397 if (Comma == StringRef::npos ||
4398 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4399 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4400 Diags.
Report(diag::err_drv_preamble_format);
4408 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4409 StringRef Name = A->getValue();
4410 if (Name ==
"branch")
4412 else if (Name ==
"return")
4414 else if (Name ==
"full")
4419 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4420 if (A->getOption().matches(OPT_D))
4427 for (
const auto *A : Args.filtered(OPT_include))
4428 Opts.
Includes.emplace_back(A->getValue());
4430 for (
const auto *A : Args.filtered(OPT_chain_include))
4433 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4434 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4436 if (Split.second.empty()) {
4437 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4444 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4445 StringRef Epoch = A->getValue();
4449 const uint64_t MaxTimestamp =
4450 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4452 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4453 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4454 << Epoch << MaxTimestamp;
4475#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4476 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4477#include "clang/Driver/Options.inc"
4478#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4496#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4497 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4498#include "clang/Driver/Options.inc"
4499#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4502 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4511#define TARGET_OPTION_WITH_MARSHALLING(...) \
4512 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4513#include "clang/Driver/Options.inc"
4514#undef TARGET_OPTION_WITH_MARSHALLING
4520 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,
4530#define TARGET_OPTION_WITH_MARSHALLING(...) \
4531 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4532#include "clang/Driver/Options.inc"
4533#undef TARGET_OPTION_WITH_MARSHALLING
4535 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4536 llvm::VersionTuple Version;
4537 if (Version.tryParse(A->getValue()))
4538 Diags.
Report(diag::err_drv_invalid_value)
4539 << A->getAsString(Args) << A->getValue();
4544 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4545 llvm::VersionTuple Version;
4546 if (Version.tryParse(A->getValue()))
4547 Diags.
Report(diag::err_drv_invalid_value)
4548 << A->getAsString(Args) << A->getValue();
4556bool CompilerInvocation::CreateFromArgsImpl(
4564 unsigned MissingArgIndex, MissingArgCount;
4565 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4566 MissingArgCount, VisibilityMask);
4570 if (MissingArgCount)
4571 Diags.
Report(diag::err_drv_missing_argument)
4572 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4575 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4576 auto ArgString = A->getAsString(Args);
4577 std::string Nearest;
4578 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)
4579 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4581 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4582 << ArgString << Nearest;
4629 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4630 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4631 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4632 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4645 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4651 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4665 Diags, llvm::vfs::getRealFileSystem());
4679 const char *Argv0) {
4685 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4689 Args.push_back(
"-cc1");
4692 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4697 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;
4710#define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
4711#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4712 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
4713#define BENIGN_LANGOPT(Name, Bits, Default, Description)
4714#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4715#include "clang/Basic/LangOptions.def"
4720 HBuilder.addRange(
getLangOpts().CommentOpts.BlockCommandNames);
4737 StringRef MacroDef = Macro.first;
4739 llvm::CachedHashString(MacroDef.split(
'=').first)))
4743 HBuilder.add(Macro);
4758#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
4759#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4760 HBuilder.add(diagOpts.get##Name());
4761#include "clang/Basic/DiagnosticOptions.def"
4771 ext->hashExtension(HBuilder);
4778 HBuilder.add(*Minor);
4779 if (
auto Subminor =
APINotesOpts.SwiftVersion.getSubminor())
4780 HBuilder.add(*Subminor);
4782 HBuilder.add(*Build);
4794 if (!SanHash.
empty())
4795 HBuilder.add(SanHash.
Mask);
4797 llvm::MD5::MD5Result
Result;
4798 HBuilder.getHasher().final(
Result);
4800 return toString(llvm::APInt(64, Hash), 36,
false);
4827 std::vector<std::string> Args{
"-cc1"};
4829 [&Args](
const Twine &Arg) { Args.push_back(Arg.str()); });
4854 llvm::vfs::getRealFileSystem());
4862 Diags, std::move(BaseFS));
4868 if (VFSOverlayFiles.empty())
4873 for (
const auto &
File : VFSOverlayFiles) {
4874 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
4877 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
4882 std::move(Buffer.get()),
nullptr,
File,
4885 Diags.
Report(diag::err_invalid_vfs_overlay) <<
File;
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static void getAllNoBuiltinFuncValues(ArgList &Args, std::vector< std::string > &Funcs)
static T extractMaskValue(T KeyPath)
static std::optional< IntTy > normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &Diags)
static T mergeMaskValue(T KeyPath, U Value)
static std::optional< std::string > normalizeString(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, OptSpecifier OtherOpt)
static SmallVector< StringRef, 4 > serializeSanitizerKinds(SanitizerSet S)
static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, ArgList &Args, DiagnosticsEngine &D, XRayInstrSet &S)
static unsigned getOptimizationLevelSize(ArgList &Args)
static void GenerateFrontendArgs(const FrontendOptions &Opts, ArgumentConsumer Consumer, bool IsHeader)
static std::optional< SimpleEnumValue > findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value)
static bool ParseTargetArgs(TargetOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static auto makeFlagToValueNormalizer(T Value)
static void denormalizeStringVector(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, const std::vector< std::string > &Values)
static CodeGenOptions::OptRemark ParseOptimizationRemark(DiagnosticsEngine &Diags, ArgList &Args, OptSpecifier OptEQ, StringRef Name)
Parse a remark command line argument.
static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static constexpr bool is_uint64_t_convertible()
static std::optional< SimpleEnumValue > findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name)
static std::optional< OptSpecifier > getProgramActionOpt(frontend::ActionKind ProgramAction)
Maps frontend action to command line option.
static bool parseDiagnosticLevelMask(StringRef FlagName, const std::vector< std::string > &Levels, DiagnosticsEngine &Diags, DiagnosticLevelMask &M)
static std::optional< bool > normalizeSimpleFlag(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
CompilerInvocation::ArgumentConsumer ArgumentConsumer
static void GenerateArg(ArgumentConsumer Consumer, llvm::opt::OptSpecifier OptSpecifier)
static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, OptSpecifier GroupWithValue, std::vector< std::string > &Diagnostics)
static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, DiagnosticsEngine *Diags)
static void denormalizeSimpleEnum(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static bool ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, const FrontendOptions &FrontendOpts)
static std::optional< unsigned > normalizeSimpleEnum(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static StringRef GetInputKindName(InputKind IK)
Get language name for given input kind.
static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, StringRef &OptionField, StringRef Name, StringRef DefaultVal)
static void denormalizeString(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static std::optional< std::string > normalizeTriple(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
llvm::function_ref< bool(CompilerInvocation &, ArrayRef< const char * >, DiagnosticsEngine &, const char *)> ParseFn
llvm::function_ref< void(CompilerInvocation &, SmallVectorImpl< const char * > &, CompilerInvocation::StringAllocator)> GenerateFn
static void GenerateMigratorArgs(const MigratorOptions &Opts, ArgumentConsumer Consumer)
static const auto & getFrontendActionTable()
Return a table that associates command line option specifiers with the frontend action.
static void GenerateTargetArgs(const TargetOptions &Opts, ArgumentConsumer Consumer)
static std::optional< frontend::ActionKind > getFrontendAction(OptSpecifier &Opt)
Maps command line option to frontend action.
static bool checkVerifyPrefixes(const std::vector< std::string > &VerifyPrefixes, DiagnosticsEngine &Diags)
static void denormalizeSimpleFlag(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass, unsigned,...)
The tblgen-erated code passes in a fifth parameter of an arbitrary type, but denormalizeSimpleFlags n...
static void GenerateAPINotesArgs(const APINotesOptions &Opts, ArgumentConsumer Consumer)
static std::optional< bool > normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, const ArgList &Args, DiagnosticsEngine &)
static void GenerateFileSystemArgs(const FileSystemOptions &Opts, ArgumentConsumer Consumer)
static bool IsInputCompatibleWithStandard(InputKind IK, const LangStandard &S)
Check if input file kind and language standard are compatible.
static void denormalizeStringImpl(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned, const Twine &Value)
static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName, llvm::vfs::FileSystem &FS, DiagnosticsEngine &Diags)
static void denormalizeSimpleEnumImpl(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, unsigned Value)
static void GeneratePreprocessorArgs(const PreprocessorOptions &Opts, ArgumentConsumer Consumer, const LangOptions &LangOpts, const FrontendOptions &FrontendOpts, const CodeGenOptions &CodeGenOpts)
static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, const std::string &WorkingDir)
static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, bool &IsHeaderFile)
static auto makeBooleanOptionDenormalizer(bool Value)
static void GeneratePreprocessorOutputArgs(const PreprocessorOutputOptions &Opts, ArgumentConsumer Consumer, frontend::ActionKind Action)
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action)
static std::string serializeXRayInstrumentationBundle(const XRayInstrSet &S)
static bool ParseMigratorArgs(MigratorOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor)
static T mergeForwardValue(T KeyPath, U Value)
static void ParseAPINotesArgs(APINotesOptions &Opts, ArgList &Args, DiagnosticsEngine &diags)
static bool ParseDependencyOutputArgs(DependencyOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, bool ShowLineMarkers)
static Expected< std::optional< uint32_t > > parseToleranceOption(StringRef Arg)
static std::optional< std::vector< std::string > > normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &)
static void GenerateAnalyzerArgs(const AnalyzerOptions &Opts, ArgumentConsumer Consumer)
static void GenerateOptimizationRemark(ArgumentConsumer Consumer, OptSpecifier OptEQ, StringRef Name, const CodeGenOptions::OptRemark &Remark)
Generate a remark argument. This is an inverse of ParseOptimizationRemark.
static bool ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action)
static bool RoundTrip(ParseFn Parse, GenerateFn Generate, CompilerInvocation &RealInvocation, CompilerInvocation &DummyInvocation, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0, bool CheckAgainstOriginalInvocation=false, bool ForceRoundTrip=false)
May perform round-trip of command line arguments.
static T extractForwardValue(T KeyPath)
static unsigned getOptimizationLevel(ArgList &Args, InputKind IK, DiagnosticsEngine &Diags)
static bool parseTestModuleFileExtensionArg(StringRef Arg, std::string &BlockName, unsigned &MajorVersion, unsigned &MinorVersion, bool &Hashed, std::string &UserInfo)
Parse the argument to the -ftest-module-file-extension command-line argument.
static void GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts, ArgumentConsumer Consumer)
static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config, StringRef OptionName, StringRef DefaultVal)
static bool FixupInvocation(CompilerInvocation &Invocation, DiagnosticsEngine &Diags, const ArgList &Args, InputKind IK)
static void parseSanitizerKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S)
static void GenerateHeaderSearchArgs(const HeaderSearchOptions &Opts, ArgumentConsumer Consumer)
Defines the clang::FileSystemOptions interface.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Defines types useful for describing an Objective-C runtime.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::SanitizerKind enum.
Defines the clang::SourceLocation class and associated facilities.
Defines the clang::TargetOptions class.
Defines version macros and version-related utility functions for Clang.
Defines the clang::Visibility enumeration and various utility functions.
Defines the clang::XRayInstrKind enum.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Tracks various options which control how API notes are found and handled.
llvm::VersionTuple SwiftVersion
The Swift version which should be used for API notes.
std::vector< std::string > ModuleSearchPaths
The set of search paths where we API notes can be found for particular modules.
Stores options for the analyzer from the command line.
static std::vector< StringRef > getRegisteredPackages(bool IncludeExperimental=false)
Retrieves the list of packages generated from Checkers.td.
std::vector< std::pair< std::string, bool > > CheckersAndPackages
Pairs of checker/package name and enable/disable.
std::vector< std::string > SilencedCheckersAndPackages
Vector of checker/package names which will not emit warnings.
AnalysisDiagClients AnalysisDiagOpt
AnalysisConstraints AnalysisConstraintsOpt
ConfigTable Config
A key-value table of use-specified configuration values.
unsigned ShouldEmitErrorsOnInvalidConfigValue
AnalysisPurgeMode AnalysisPurgeOpt
bool isUnknownAnalyzerConfig(llvm::StringRef Name)
static std::vector< StringRef > getRegisteredCheckers(bool IncludeExperimental=false)
Retrieves the list of checkers generated from Checkers.td.
llvm::StringMap< std::string > ConfigTable
std::string FullCompilerInvocation
Store full compiler invocation for reproducible instructions in the generated report.
AnalysisInliningMode InliningMode
The mode of function selection used during inlining.
static bool isBuiltinFunc(llvm::StringRef Name)
Returns true if this is a libc/libm function without the '__builtin_' prefix.
Implements C++ ABI-specific semantic analysis functions.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
llvm::SmallVector< std::pair< std::string, std::string >, 0 > CoveragePrefixMap
Prefix replacement map for source-based code coverage to remap source file paths in coverage mapping.
llvm::SmallVector< std::pair< std::string, std::string >, 0 > DebugPrefixMap
std::string OptRecordFile
The name of the file to which the backend should save YAML optimization records.
std::string BinutilsVersion
std::vector< BitcodeFileToLink > LinkBitcodeFiles
The files specified here are linked in to the module before optimizations.
std::optional< uint64_t > DiagnosticsHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
char CoverageVersion[4]
The version string to put into coverage files.
llvm::DenormalMode FPDenormalMode
The floating-point denormal mode to use.
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
uint64_t LargeDataThreshold
The code model-specific large data threshold to use (-mlarge-data-threshold).
std::string MemoryProfileOutput
Name of the profile file to use as output for with -fmemory-profile.
std::string CodeModel
The code model to use (-mcmodel).
std::string CoverageDataFile
The filename with path we use for coverage data files.
std::optional< uint32_t > DiagnosticsMisExpectTolerance
The maximum percentage profiling weights can deviate from the expected values in order to be included...
std::string StackUsageOutput
Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.