29#include "clang/Config/config.h"
48#include "llvm/ADT/APInt.h"
49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/CachedHashString.h"
51#include "llvm/ADT/FloatingPointMode.h"
52#include "llvm/ADT/Hashing.h"
53#include "llvm/ADT/STLExtras.h"
54#include "llvm/ADT/SmallString.h"
55#include "llvm/ADT/SmallVector.h"
56#include "llvm/ADT/StringRef.h"
57#include "llvm/ADT/StringSwitch.h"
58#include "llvm/ADT/Twine.h"
59#include "llvm/Config/llvm-config.h"
60#include "llvm/Frontend/Debug/Options.h"
61#include "llvm/IR/DebugInfoMetadata.h"
62#include "llvm/Linker/Linker.h"
63#include "llvm/MC/MCTargetOptions.h"
64#include "llvm/Option/Arg.h"
65#include "llvm/Option/ArgList.h"
66#include "llvm/Option/OptSpecifier.h"
67#include "llvm/Option/OptTable.h"
68#include "llvm/Option/Option.h"
69#include "llvm/ProfileData/InstrProfReader.h"
70#include "llvm/Remarks/HotnessThresholdParser.h"
71#include "llvm/Support/CodeGen.h"
72#include "llvm/Support/Compiler.h"
73#include "llvm/Support/Error.h"
74#include "llvm/Support/ErrorHandling.h"
75#include "llvm/Support/ErrorOr.h"
76#include "llvm/Support/FileSystem.h"
77#include "llvm/Support/HashBuilder.h"
78#include "llvm/Support/MathExtras.h"
79#include "llvm/Support/MemoryBuffer.h"
80#include "llvm/Support/Path.h"
81#include "llvm/Support/Process.h"
82#include "llvm/Support/Regex.h"
83#include "llvm/Support/VersionTuple.h"
84#include "llvm/Support/VirtualFileSystem.h"
85#include "llvm/Support/raw_ostream.h"
86#include "llvm/Target/TargetOptions.h"
87#include "llvm/TargetParser/Host.h"
88#include "llvm/TargetParser/Triple.h"
101#include <type_traits>
105using namespace clang;
106using namespace driver;
107using namespace options;
118 if (Arg.getAsInteger(10, Val))
119 return llvm::createStringError(llvm::inconvertibleErrorCode(),
120 "Not an integer: %s", Arg.data());
129template <
class T> std::shared_ptr<T> make_shared_copy(
const T &
X) {
130 return std::make_shared<T>(
X);
135 return llvm::makeIntrusiveRefCnt<T>(
X);
157 LangOpts = make_shared_copy(
X.getLangOpts());
160 HSOpts = make_shared_copy(
X.getHeaderSearchOpts());
161 PPOpts = make_shared_copy(
X.getPreprocessorOpts());
166 FSOpts = make_shared_copy(
X.getFileSystemOpts());
207T &ensureOwned(std::shared_ptr<T> &Storage) {
208 if (Storage.use_count() > 1)
209 Storage = std::make_shared<T>(*Storage);
215 if (Storage.useCount() > 1)
216 Storage = llvm::makeIntrusiveRefCnt<T>(*Storage);
234 return ensureOwned(
HSOpts);
238 return ensureOwned(
PPOpts);
258 return ensureOwned(
FSOpts);
280#define OPTTABLE_STR_TABLE_CODE
281#include "clang/Driver/Options.inc"
282#undef OPTTABLE_STR_TABLE_CODE
285 return &OptionStrTable[Offset];
288#define SIMPLE_ENUM_VALUE_TABLE
289#include "clang/Driver/Options.inc"
290#undef SIMPLE_ENUM_VALUE_TABLE
296 if (Args.hasArg(Opt))
305 if (Args.hasArg(Opt))
315 unsigned SpellingOffset, Option::OptionClass,
320 const Twine &Spelling, Option::OptionClass,
326 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
330 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
332 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
334 if (Args.hasArg(Opt))
341 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
347 OptSpecifier OtherOpt) {
348 return [
Value, OtherValue,
349 OtherOpt](OptSpecifier Opt,
unsigned,
const ArgList &Args,
351 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
352 return A->getOption().matches(Opt) ?
Value : OtherValue;
360 Option::OptionClass,
unsigned,
bool KeyPath) {
361 if (KeyPath ==
Value)
367 const Twine &Spelling,
368 Option::OptionClass OptClass,
unsigned,
369 const Twine &
Value) {
371 case Option::SeparateClass:
372 case Option::JoinedOrSeparateClass:
373 case Option::JoinedAndSeparateClass:
377 case Option::JoinedClass:
378 case Option::CommaJoinedClass:
379 Consumer(Spelling +
Value);
382 llvm_unreachable(
"Cannot denormalize an option with option class "
383 "incompatible with string denormalization.");
390 Option::OptionClass OptClass,
unsigned TableIndex,
T Value) {
392 TableIndex, Twine(
Value));
397 Option::OptionClass OptClass,
unsigned TableIndex,
402static std::optional<SimpleEnumValue>
404 for (
int I = 0,
E = Table.Size; I !=
E; ++I)
405 if (Name == Table.Table[I].Name)
406 return Table.Table[I];
411static std::optional<SimpleEnumValue>
413 for (
int I = 0,
E = Table.Size; I !=
E; ++I)
415 return Table.Table[I];
424 assert(TableIndex < SimpleEnumValueTablesSize);
425 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
427 auto *Arg = Args.getLastArg(Opt);
431 StringRef ArgValue = Arg->getValue();
433 return MaybeEnumVal->Value;
435 Diags.
Report(diag::err_drv_invalid_value)
436 << Arg->getAsString(Args) << ArgValue;
441 unsigned SpellingOffset,
442 Option::OptionClass OptClass,
443 unsigned TableIndex,
unsigned Value) {
444 assert(TableIndex < SimpleEnumValueTablesSize);
445 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
448 TableIndex, MaybeEnumVal->Name);
450 llvm_unreachable(
"The simple enum value was not correctly defined in "
451 "the tablegen option description");
457 unsigned SpellingOffset,
458 Option::OptionClass OptClass,
459 unsigned TableIndex,
T Value) {
461 TableIndex,
static_cast<unsigned>(
Value));
468 auto *Arg = Args.getLastArg(Opt);
471 return std::string(Arg->getValue());
474template <
typename IntTy>
478 auto *Arg = Args.getLastArg(Opt);
482 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
483 Diags.
Report(diag::err_drv_invalid_int_value)
484 << Arg->getAsString(Args) << Arg->getValue();
490static std::optional<std::vector<std::string>>
493 return Args.getAllArgValues(Opt);
497 unsigned SpellingOffset,
498 Option::OptionClass OptClass,
500 const std::vector<std::string> &Values) {
502 case Option::CommaJoinedClass: {
503 std::string CommaJoinedValue;
504 if (!Values.empty()) {
505 CommaJoinedValue.append(Values.front());
506 for (
const std::string &
Value : llvm::drop_begin(Values, 1)) {
507 CommaJoinedValue.append(
",");
508 CommaJoinedValue.append(
Value);
512 Option::OptionClass::JoinedClass, TableIndex,
516 case Option::JoinedClass:
517 case Option::SeparateClass:
518 case Option::JoinedOrSeparateClass:
519 for (
const std::string &
Value : Values)
523 llvm_unreachable(
"Cannot denormalize an option with option class "
524 "incompatible with string vector denormalization.");
532 auto *Arg = Args.getLastArg(Opt);
535 return llvm::Triple::normalize(Arg->getValue());
538template <
typename T,
typename U>
540 return static_cast<T>(
Value);
544 return KeyPath |
Value;
551template <
typename T,
typename U, U Value>
556#define PARSE_OPTION_WITH_MARSHALLING( \
557 ARGS, DIAGS, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, \
558 ALIASARGS, FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, \
559 METAVAR, VALUES, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
560 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
562 if ((VISIBILITY) & options::CC1Option) { \
563 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
565 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
567 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
569 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
574#define GENERATE_OPTION_WITH_MARSHALLING( \
575 CONSUMER, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, ALIASARGS, \
576 FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
577 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
578 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
579 if ((VISIBILITY) & options::CC1Option) { \
580 [&](const auto &Extracted) { \
583 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
584 : (DEFAULT_VALUE)))) \
585 DENORMALIZER(CONSUMER, SPELLING_OFFSET, Option::KIND##Class, \
586 TABLE_INDEX, Extracted); \
587 }(EXTRACTOR(KEYPATH)); \
601 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
602 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
603 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
604 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
607 CodeGenOpts.ClearASTBeforeBackend =
false;
609 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
610 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
613 llvm::Triple
T(TargetOpts.
Triple);
614 llvm::Triple::ArchType Arch =
T.getArch();
619 if (LangOpts.getExceptionHandling() !=
621 T.isWindowsMSVCEnvironment())
622 Diags.
Report(diag::err_fe_invalid_exception_model)
623 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) <<
T.str();
625 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
626 Diags.
Report(diag::warn_c_kext);
628 if (LangOpts.NewAlignOverride &&
629 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
630 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
631 Diags.
Report(diag::err_fe_invalid_alignment)
632 << A->getAsString(Args) << A->getValue();
633 LangOpts.NewAlignOverride = 0;
638 if (LangOpts.CPlusPlus11) {
639 if (Args.hasArg(OPT_fraw_string_literals, OPT_fno_raw_string_literals)) {
640 Args.claimAllArgs(OPT_fraw_string_literals, OPT_fno_raw_string_literals);
641 Diags.
Report(diag::warn_drv_fraw_string_literals_in_cxx11)
642 <<
bool(LangOpts.RawStringLiterals);
646 LangOpts.RawStringLiterals =
true;
650 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
651 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
654 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
655 Diags.
Report(diag::err_drv_argument_not_allowed_with)
658 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
659 Diags.
Report(diag::err_drv_argument_not_allowed_with)
662 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
663 Diags.
Report(diag::warn_ignored_hip_only_option)
664 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
666 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
667 Diags.
Report(diag::warn_ignored_hip_only_option)
668 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
677 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
678 if (LangOpts.ApproxFunc)
679 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
680 if (LangOpts.AllowFPReassoc)
681 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
682 if (LangOpts.AllowRecip)
683 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
689 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
691 Diags.
Report(diag::warn_option_invalid_ocl_version)
693 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
695 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
696 auto DefaultCC = LangOpts.getDefaultCallingConv();
700 Arch != llvm::Triple::x86;
706 Diags.
Report(diag::err_drv_argument_not_allowed_with)
707 << A->getSpelling() <<
T.getTriple();
719 unsigned DefaultOpt = 0;
722 !Args.hasArg(OPT_cl_opt_disable))
725 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
726 if (A->getOption().matches(options::OPT_O0))
729 if (A->getOption().matches(options::OPT_Ofast))
732 assert(A->getOption().matches(options::OPT_O));
734 StringRef S(A->getValue());
735 if (S ==
"s" || S ==
"z")
748 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
749 if (A->getOption().matches(options::OPT_O)) {
750 switch (A->getValue()[0]) {
764 llvm::opt::OptSpecifier OptSpecifier) {
767 Option::OptionClass::FlagClass, 0);
771 llvm::opt::OptSpecifier OptSpecifier,
772 const Twine &
Value) {
810 bool CheckAgainstOriginalInvocation =
false,
811 bool ForceRoundTrip =
false) {
813 bool DoRoundTripDefault =
true;
815 bool DoRoundTripDefault =
false;
818 bool DoRoundTrip = DoRoundTripDefault;
819 if (ForceRoundTrip) {
822 for (
const auto *Arg : CommandLineArgs) {
823 if (Arg == StringRef(
"-round-trip-args"))
825 if (Arg == StringRef(
"-no-round-trip-args"))
833 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
838 llvm::raw_string_ostream OS(Buffer);
839 for (
const char *Arg : Args) {
840 llvm::sys::printArg(OS, Arg,
true);
852 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
859 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
865 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
866 Diags.
Report(diag::note_cc1_round_trip_original)
867 << SerializeArgs(CommandLineArgs);
872 llvm::BumpPtrAllocator Alloc;
873 llvm::StringSaver StringPool(Alloc);
874 auto SA = [&StringPool](
const Twine &Arg) {
875 return StringPool.save(Arg).data();
882 Generate(DummyInvocation, GeneratedArgs, SA);
888 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
893 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
894 Diags.
Report(diag::note_cc1_round_trip_generated)
895 << 1 << SerializeArgs(GeneratedArgs);
900 if (CheckAgainstOriginalInvocation)
902 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
906 Generate(RealInvocation, ComparisonArgs, SA);
911 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
912 [](
const char *AElem,
const char *BElem) {
913 return StringRef(AElem) == StringRef(BElem);
920 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
921 Diags.
Report(diag::err_cc1_round_trip_mismatch);
922 Diags.
Report(diag::note_cc1_round_trip_generated)
923 << 1 << SerializeArgs(GeneratedArgs);
924 Diags.
Report(diag::note_cc1_round_trip_generated)
925 << 2 << SerializeArgs(ComparisonArgs);
929 Diags.
Report(diag::remark_cc1_round_trip_generated)
930 << 1 << SerializeArgs(GeneratedArgs);
931 Diags.
Report(diag::remark_cc1_round_trip_generated)
932 << 2 << SerializeArgs(ComparisonArgs);
944 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
948 Args.push_back(
"-cc1");
951 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
956 OptSpecifier GroupWithValue,
957 std::vector<std::string> &Diagnostics) {
958 for (
auto *A : Args.filtered(Group)) {
959 if (A->getOption().getKind() == Option::FlagClass) {
962 Diagnostics.push_back(
963 std::string(A->getOption().getName().drop_front(1)));
964 }
else if (A->getOption().matches(GroupWithValue)) {
967 Diagnostics.push_back(
968 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
971 Diagnostics.push_back(A->getValue());
982 std::vector<std::string> &Funcs) {
983 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
985 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
992#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
993 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
994#include "clang/Driver/Options.inc"
995#undef ANALYZER_OPTION_WITH_MARSHALLING
999#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1001 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \
1003#include "clang/StaticAnalyzer/Core/Analyses.def"
1005 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
1011#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1013 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \
1015#include "clang/StaticAnalyzer/Core/Analyses.def"
1017 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
1023#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1025 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \
1027#include "clang/StaticAnalyzer/Core/Analyses.def"
1029 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
1035#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1037 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \
1039#include "clang/StaticAnalyzer/Core/Analyses.def"
1041 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
1047 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
1056 for (
const auto &
C : Opts.
Config)
1057 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
1058 llvm::sort(SortedConfigOpts, llvm::less_first());
1060 for (
const auto &[Key,
Value] : SortedConfigOpts) {
1063 auto Entry = ConfigOpts.
Config.find(Key);
1064 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
1079#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
1080 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1081#include "clang/Driver/Options.inc"
1082#undef ANALYZER_OPTION_WITH_MARSHALLING
1084 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
1085 StringRef Name = A->getValue();
1087#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1088 .Case(CMDFLAG, NAME##Model)
1089#include "clang/StaticAnalyzer/Core/Analyses.def"
1092 Diags.
Report(diag::err_drv_invalid_value)
1093 << A->getAsString(Args) << Name;
1096 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
1097 Diags.
Report(diag::err_analyzer_not_built_with_z3);
1104 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
1105 StringRef Name = A->getValue();
1107#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1108 .Case(CMDFLAG, PD_##NAME)
1109#include "clang/StaticAnalyzer/Core/Analyses.def"
1112 Diags.
Report(diag::err_drv_invalid_value)
1113 << A->getAsString(Args) << Name;
1119 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
1120 StringRef Name = A->getValue();
1122#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1123 .Case(CMDFLAG, NAME)
1124#include "clang/StaticAnalyzer/Core/Analyses.def"
1127 Diags.
Report(diag::err_drv_invalid_value)
1128 << A->getAsString(Args) << Name;
1134 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
1135 StringRef Name = A->getValue();
1137#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1138 .Case(CMDFLAG, NAME)
1139#include "clang/StaticAnalyzer/Core/Analyses.def"
1142 Diags.
Report(diag::err_drv_invalid_value)
1143 << A->getAsString(Args) << Name;
1151 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1153 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1156 StringRef CheckerAndPackageList = A->getValue();
1158 CheckerAndPackageList.split(CheckersAndPackages,
",");
1159 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1165 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1169 StringRef configList = A->getValue();
1171 configList.split(configVals,
",");
1172 for (
const auto &configVal : configVals) {
1174 std::tie(key, val) = configVal.split(
"=");
1177 diag::err_analyzer_config_no_value) << configVal;
1180 if (val.contains(
'=')) {
1182 diag::err_analyzer_config_multiple_values)
1191 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1196 Opts.
Config[key] = std::string(val);
1206 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1209 os << Args.getArgString(i);
1216 StringRef OptionName, StringRef DefaultVal) {
1217 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1222 StringRef &OptionField, StringRef Name,
1223 StringRef DefaultVal) {
1232 bool &OptionField, StringRef Name,
bool DefaultVal) {
1233 auto PossiblyInvalidVal =
1234 llvm::StringSwitch<std::optional<bool>>(
1237 .Case(
"false",
false)
1238 .Default(std::nullopt);
1240 if (!PossiblyInvalidVal) {
1242 Diags->
Report(diag::err_analyzer_config_invalid_input)
1243 << Name <<
"a boolean";
1245 OptionField = DefaultVal;
1247 OptionField = *PossiblyInvalidVal;
1252 unsigned &OptionField, StringRef Name,
1253 unsigned DefaultVal) {
1255 OptionField = DefaultVal;
1256 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1257 .getAsInteger(0, OptionField);
1258 if (Diags && HasFailed)
1259 Diags->
Report(diag::err_analyzer_config_invalid_input)
1260 << Name <<
"an unsigned";
1266 unsigned DefaultVal) {
1269 if (Parsed.has_value()) {
1270 OptionField = Parsed.value();
1273 if (Diags && !Parsed.has_value())
1274 Diags->
Report(diag::err_analyzer_config_invalid_input)
1275 << Name <<
"a positive";
1277 OptionField = DefaultVal;
1285#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1286 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1287#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1288#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1290 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1291 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1293#define ANALYZER_OPTION(...)
1294#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1295 SHALLOW_VAL, DEEP_VAL) \
1296 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1297 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1298#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1305 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1306 std::vector<StringRef> Checkers =
1308 std::vector<StringRef> Packages =
1312 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1314 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1316 bool IsChecker = CheckerOrPackage.contains(
'.');
1317 bool IsValidName = IsChecker
1318 ? llvm::is_contained(Checkers, CheckerOrPackage)
1319 : llvm::is_contained(Packages, CheckerOrPackage);
1322 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1323 << CheckerOrPackage;
1333 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1334 Diags->
Report(diag::err_analyzer_config_invalid_input)
1335 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1337 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1338 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1341 if (!AnOpts.ModelPath.empty() &&
1342 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1343 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1352 if (
Remark.hasValidPattern()) {
1357 GenerateArg(Consumer, OPT_R_Joined, StringRef(
"no-") + Name);
1366 OptSpecifier OptEQ, StringRef Name) {
1369 auto InitializeResultPattern = [&Diags, &Args, &
Result](
const Arg *A,
1370 StringRef Pattern) {
1371 Result.Pattern = Pattern.str();
1373 std::string RegexError;
1374 Result.Regex = std::make_shared<llvm::Regex>(
Result.Pattern);
1375 if (!
Result.Regex->isValid(RegexError)) {
1376 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1377 << RegexError << A->getAsString(Args);
1384 for (Arg *A : Args) {
1385 if (A->getOption().matches(OPT_R_Joined)) {
1386 StringRef
Value = A->getValue();
1390 else if (
Value ==
"everything")
1392 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1394 else if (
Value ==
"no-everything")
1404 InitializeResultPattern(A,
".*");
1406 }
else if (A->getOption().matches(OptEQ)) {
1408 if (!InitializeResultPattern(A, A->getValue()))
1417 const std::vector<std::string> &Levels,
1421 for (
const auto &Level : Levels) {
1423 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1431 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1439 const std::vector<std::string> &Sanitizers,
1441 for (
const auto &Sanitizer : Sanitizers) {
1444 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1458 const std::vector<std::string> &Sanitizers,
1461 for (
const auto &Sanitizer : Sanitizers) {
1463 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1472 llvm::SplitString(Bundle, BundleParts,
",");
1473 for (
const auto &B : BundleParts) {
1477 D.Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1491 llvm::raw_string_ostream OS(Buffer);
1492 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1498 const Twine &ProfileName,
1499 llvm::vfs::FileSystem &FS,
1501 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);
1502 if (
auto E = ReaderOrErr.takeError()) {
1504 "Error in reading profile %0: %1");
1505 llvm::handleAllErrors(std::move(
E), [&](
const llvm::ErrorInfoBase &EI) {
1506 Diags.
Report(DiagID) << ProfileName.str() << EI.message();
1510 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1511 std::move(ReaderOrErr.get());
1515 if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1516 if (PGOReader->hasCSIRLevelProfile())
1526 const llvm::Triple &Triple) {
1527 assert(Triple.getArch() == llvm::Triple::aarch64);
1534 LangOpts.PointerAuthFunctionTypeDiscrimination ? Discrimination::Type
1535 : Discrimination::None);
1538 Key::ASDA,
LangOpts.PointerAuthVTPtrAddressDiscrimination,
1539 LangOpts.PointerAuthVTPtrTypeDiscrimination ? Discrimination::Type
1540 : Discrimination::None);
1542 if (
LangOpts.PointerAuthTypeInfoVTPtrDiscrimination)
1557 if (
LangOpts.PointerAuthInitFini) {
1559 Key::ASIA,
LangOpts.PointerAuthInitFiniAddressDiscrimination,
1571 const llvm::Triple &Triple,
1573 if (!LangOpts.PointerAuthCalls && !LangOpts.PointerAuthReturns &&
1574 !LangOpts.PointerAuthAuthTraps && !LangOpts.PointerAuthIndirectGotos &&
1575 !LangOpts.AArch64JumpTableHardening)
1581void CompilerInvocationBase::GenerateCodeGenArgs(
const CodeGenOptions &Opts,
1583 const llvm::Triple &
T,
1584 const std::string &OutputFile,
1588 if (Opts.OptimizationLevel == 0)
1591 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));
1593#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1594 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
1595#include "clang/Driver/Options.inc"
1596#undef CODEGEN_OPTION_WITH_MARSHALLING
1598 if (Opts.OptimizationLevel > 0) {
1602 GenerateArg(Consumer, OPT_finline_hint_functions);
1607 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1608 GenerateArg(Consumer, OPT_fdirect_access_external_data);
1609 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1610 GenerateArg(Consumer, OPT_fno_direct_access_external_data);
1612 std::optional<StringRef> DebugInfoVal;
1613 switch (Opts.DebugInfo) {
1614 case llvm::codegenoptions::DebugLineTablesOnly:
1615 DebugInfoVal =
"line-tables-only";
1617 case llvm::codegenoptions::DebugDirectivesOnly:
1618 DebugInfoVal =
"line-directives-only";
1620 case llvm::codegenoptions::DebugInfoConstructor:
1621 DebugInfoVal =
"constructor";
1623 case llvm::codegenoptions::LimitedDebugInfo:
1624 DebugInfoVal =
"limited";
1626 case llvm::codegenoptions::FullDebugInfo:
1627 DebugInfoVal =
"standalone";
1629 case llvm::codegenoptions::UnusedTypeInfo:
1630 DebugInfoVal =
"unused-types";
1632 case llvm::codegenoptions::NoDebugInfo:
1633 DebugInfoVal = std::nullopt;
1635 case llvm::codegenoptions::LocTrackingOnly:
1636 DebugInfoVal = std::nullopt;
1640 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
1644 Prefix.first +
"=" + Prefix.second);
1647 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
1648 Prefix.first +
"=" + Prefix.second);
1650 if (Opts.NewStructPathTBAA)
1653 if (Opts.OptimizeSize == 1)
1655 else if (Opts.OptimizeSize == 2)
1663 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1665 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1671 if (Opts.DebugNameTable ==
1672 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1674 else if (Opts.DebugNameTable ==
1675 static_cast<unsigned>(
1676 llvm::DICompileUnit::DebugNameTableKind::Default))
1679 if (Opts.DebugTemplateAlias)
1682 auto TNK = Opts.getDebugSimpleTemplateNames();
1683 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1684 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1685 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"simple");
1686 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1687 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"mangled");
1692 if (Opts.TimePasses) {
1693 if (Opts.TimePassesPerRun)
1694 GenerateArg(Consumer, OPT_ftime_report_EQ,
"per-pass-run");
1699 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1702 if (Opts.PrepareForThinLTO)
1711 StringRef MemProfileBasename(
"memprof.profraw");
1732 std::string InstrBundle =
1734 if (!InstrBundle.empty())
1735 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);
1738 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1739 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"full");
1740 else if (Opts.CFProtectionReturn)
1741 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"return");
1742 else if (Opts.CFProtectionBranch)
1743 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"branch");
1745 if (Opts.CFProtectionBranch) {
1746 switch (Opts.getCFBranchLabelScheme()) {
1749#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \
1750 case CFBranchLabelSchemeKind::Kind: \
1751 GenerateArg(Consumer, OPT_mcf_branch_label_scheme_EQ, #FlagVal); \
1753#include "clang/Basic/CFProtectionOptions.def"
1757 if (Opts.FunctionReturnThunks)
1758 GenerateArg(Consumer, OPT_mfunction_return_EQ,
"thunk-extern");
1761 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1762 F.PropagateAttrs && F.Internalize;
1764 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1768 if (Opts.EmulatedTLS)
1776 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,
1781 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1785 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1789 if (Opts.EnableAIXExtendedAltivecABI)
1792 if (Opts.XCOFFReadOnlyPointers)
1810 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,
1815 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,
1819 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);
1822 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);
1824 for (StringRef Sanitizer :
1826 GenerateArg(Consumer, OPT_fsanitize_merge_handlers_EQ, Sanitizer);
1830 for (std::string Sanitizer : Values)
1831 GenerateArg(Consumer, OPT_fsanitize_skip_hot_cutoff_EQ, Sanitizer);
1833 if (!Opts.EmitVersionIdentMetadata)
1836 switch (Opts.FiniteLoops) {
1848bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1851 const llvm::Triple &
T,
1852 const std::string &OutputFile,
1858 unsigned MaxOptLevel = 3;
1859 if (OptimizationLevel > MaxOptLevel) {
1862 Diags.
Report(diag::warn_drv_optimization_value)
1863 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1864 OptimizationLevel = MaxOptLevel;
1866 Opts.OptimizationLevel = OptimizationLevel;
1875#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1876 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1877#include "clang/Driver/Options.inc"
1878#undef CODEGEN_OPTION_WITH_MARSHALLING
1882 if (Opts.OptimizationLevel == 0) {
1884 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1885 options::OPT_finline_hint_functions,
1886 options::OPT_fno_inline_functions,
1887 options::OPT_fno_inline)) {
1890 if (A->getOption().matches(options::OPT_finline_functions))
1892 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1902 Opts.DirectAccessExternalData =
1903 Args.hasArg(OPT_fdirect_access_external_data) ||
1904 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1907 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1909 llvm::StringSwitch<unsigned>(A->getValue())
1910 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1911 .Case(
"line-directives-only",
1912 llvm::codegenoptions::DebugDirectivesOnly)
1913 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1914 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1915 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1916 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1919 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1922 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1928 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1929 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1930 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1931 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1932 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1933 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1934 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1937 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1938 auto Split = StringRef(Arg).split(
'=');
1942 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1943 auto Split = StringRef(Arg).split(
'=');
1947 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1948 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1949 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1950 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1953 llvm::is_contained(DebugEntryValueArchs,
T.getArch()))
1954 Opts.EmitCallSiteInfo =
true;
1957 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1962 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1963 Args.hasArg(OPT_new_struct_path_tbaa);
1965 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1966 if (Opts.SimplifyLibCalls)
1969 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1970 (Opts.OptimizationLevel > 1));
1972 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1974 Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);
1976 Opts.DebugNameTable =
static_cast<unsigned>(
1977 Args.hasArg(OPT_ggnu_pubnames)
1978 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1979 : Args.hasArg(OPT_gpubnames)
1980 ? llvm::DICompileUnit::DebugNameTableKind::Default
1981 : llvm::DICompileUnit::DebugNameTableKind::None);
1982 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1983 StringRef
Value = A->getValue();
1985 Diags.
Report(diag::err_drv_unsupported_option_argument)
1986 << A->getSpelling() << A->getValue();
1987 Opts.setDebugSimpleTemplateNames(
1988 StringRef(A->getValue()) ==
"simple"
1989 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
1990 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
1993 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1994 Opts.TimePasses =
true;
1997 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1998 StringRef Val = A->getValue();
1999 if (Val ==
"per-pass")
2000 Opts.TimePassesPerRun =
false;
2001 else if (Val ==
"per-pass-run")
2002 Opts.TimePassesPerRun =
true;
2004 Diags.
Report(diag::err_drv_invalid_value)
2005 << A->getAsString(Args) << A->getValue();
2009 Opts.PrepareForLTO =
false;
2010 Opts.PrepareForThinLTO =
false;
2011 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
2012 Opts.PrepareForLTO =
true;
2013 StringRef S = A->getValue();
2015 Opts.PrepareForThinLTO =
true;
2016 else if (S !=
"full")
2017 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
2018 if (Args.hasArg(OPT_funified_lto))
2019 Opts.PrepareForThinLTO =
true;
2021 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
2023 Diags.
Report(diag::err_drv_argument_only_allowed_with)
2024 << A->getAsString(Args) <<
"-x ir";
2026 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
2028 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
2030 llvm::StringSwitch<std::string>(A->getValue())
2031 .Case(
"obj", OutputFile)
2032 .Default(llvm::sys::path::filename(OutputFile).str());
2035 const char *MemProfileBasename =
"memprof.profraw";
2036 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
2038 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
2039 llvm::sys::path::append(
Path, MemProfileBasename);
2041 }
else if (Args.hasArg(OPT_fmemory_profile))
2045 if (Args.hasArg(OPT_coverage_version_EQ)) {
2046 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
2047 if (CoverageVersion.size() != 4) {
2048 Diags.
Report(diag::err_drv_invalid_value)
2049 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
2059 for (
const auto &A : Args) {
2061 if (A->getOption().getID() == options::OPT_o ||
2062 A->getOption().getID() == options::OPT_INPUT ||
2063 A->getOption().getID() == options::OPT_x ||
2064 A->getOption().getID() == options::OPT_fembed_bitcode ||
2065 A->getOption().matches(options::OPT_W_Group))
2068 A->render(Args, ASL);
2069 for (
const auto &arg : ASL) {
2070 StringRef ArgStr(arg);
2071 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
2077 auto XRayInstrBundles =
2078 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
2079 if (XRayInstrBundles.empty())
2082 for (
const auto &A : XRayInstrBundles)
2086 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
2087 StringRef Name = A->getValue();
2088 if (Name ==
"full") {
2089 Opts.CFProtectionReturn = 1;
2090 Opts.CFProtectionBranch = 1;
2091 }
else if (Name ==
"return")
2092 Opts.CFProtectionReturn = 1;
2093 else if (Name ==
"branch")
2094 Opts.CFProtectionBranch = 1;
2095 else if (Name !=
"none")
2096 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
2099 if (Opts.CFProtectionBranch &&
T.isRISCV()) {
2100 if (
const Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {
2102 llvm::StringSwitch<CFBranchLabelSchemeKind>(A->getValue())
2103#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \
2104 .Case(#FlagVal, CFBranchLabelSchemeKind::Kind)
2105#include "clang/Basic/CFProtectionOptions.def"
2108 Opts.setCFBranchLabelScheme(Scheme);
2110 Diags.
Report(diag::err_drv_invalid_value)
2111 << A->getAsString(Args) << A->getValue();
2115 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
2116 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
2117 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
2118 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
2119 .Default(llvm::FunctionReturnThunksKind::Invalid);
2122 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2123 << A->getSpelling() <<
T.getTriple();
2124 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
2125 Diags.
Report(diag::err_drv_invalid_value)
2126 << A->getAsString(Args) << A->getValue();
2127 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
2128 Args.getLastArgValue(OPT_mcmodel_EQ) ==
"large")
2129 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2130 << A->getAsString(Args)
2131 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
2133 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
2137 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
2140 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
2141 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
2150 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
2151 StringRef Val = A->getValue();
2155 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2158 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
2159 StringRef Val = A->getValue();
2162 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2168 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
2169 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
2173 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2174 << A->getSpelling() <<
T.str();
2176 const Option &O = A->getOption();
2177 if (O.matches(OPT_fpcc_struct_return) ||
2178 O.matches(OPT_maix_struct_return)) {
2181 assert(O.matches(OPT_freg_struct_return) ||
2182 O.matches(OPT_msvr4_struct_return));
2187 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {
2189 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2190 << A->getSpelling() <<
T.str();
2200 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,
false))
2201 Diags.
Report(diag::err_roptr_requires_data_sections);
2203 Opts.XCOFFReadOnlyPointers =
true;
2206 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
2207 if (!
T.isOSAIX() ||
T.isPPC32())
2208 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2209 << A->getSpelling() <<
T.str();
2212 bool NeedLocTracking =
false;
2215 NeedLocTracking =
true;
2217 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
2219 NeedLocTracking =
true;
2222 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
2224 NeedLocTracking =
true;
2234 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
2244 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
2247 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2248 <<
"-fdiagnostics-show-hotness";
2252 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2254 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2257 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2258 <<
"-fdiagnostics-hotness-threshold=";
2264 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2265 <<
"-fdiagnostics-hotness-threshold=";
2270 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2274 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2275 <<
"-fdiagnostics-misexpect-tolerance=";
2281 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2282 <<
"-fdiagnostics-misexpect-tolerance=";
2289 if (UsingSampleProfile)
2290 NeedLocTracking =
true;
2293 NeedLocTracking =
true;
2297 if (NeedLocTracking &&
2298 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2299 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2304 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2307 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2310 Args.getAllArgValues(OPT_fsanitize_merge_handlers_EQ),
2315 "-fsanitize-skip-hot-cutoff=",
2316 Args.getAllArgValues(OPT_fsanitize_skip_hot_cutoff_EQ), Diags);
2318 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2323 if (Args.hasArg(options::OPT_ffinite_loops))
2325 else if (Args.hasArg(options::OPT_fno_finite_loops))
2328 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2329 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2330 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2331 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2339#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2340 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2341#include "clang/Driver/Options.inc"
2342#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2347 for (
const auto &Dep : Opts.
ExtraDeps) {
2348 switch (Dep.second) {
2361 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);
2370 bool ShowLineMarkers) {
2374#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2375 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2376#include "clang/Driver/Options.inc"
2377#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2379 if (Args.hasArg(OPT_show_includes)) {
2394 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2395 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2396 StringRef Val = A->getValue();
2397 if (!Val.contains(
'='))
2401 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2402 StringRef Val = A->getValue();
2403 if (!Val.contains(
'='))
2410 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2414 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2418 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2419 StringRef Val = A->getValue();
2420 if (!Val.contains(
'='))
2430 Diags.
Report(diag::err_drv_print_header_env_var_combination_cc1)
2431 << Args.getLastArg(OPT_header_include_format_EQ)->getValue()
2432 << Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();
2446 }
ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2447 for (
auto *A : Args) {
2448 const Option &O = A->getOption();
2449 if (O.matches(options::OPT_fcolor_diagnostics)) {
2451 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2453 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2454 StringRef
Value(A->getValue());
2455 if (
Value ==
"always")
2457 else if (
Value ==
"never")
2459 else if (
Value ==
"auto")
2465 llvm::sys::Process::StandardErrHasColors());
2471 for (
const auto &Prefix : VerifyPrefixes) {
2474 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2477 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2479 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2480 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2490#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2491 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2492#include "clang/Driver/Options.inc"
2493#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2502#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2503 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2504#include "clang/Driver/Options.inc"
2505#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2513#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2514 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2515#include "clang/Driver/Options.inc"
2516#undef MIGRATOR_OPTION_WITH_MARSHALLING
2525#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2526 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2527#include "clang/Driver/Options.inc"
2528#undef MIGRATOR_OPTION_WITH_MARSHALLING
2533void CompilerInvocationBase::GenerateDiagnosticArgs(
2535 bool DefaultDiagColor) {
2537#define DIAG_OPTION_WITH_MARSHALLING(...) \
2538 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2539#include "clang/Driver/Options.inc"
2540#undef DIAG_OPTION_WITH_MARSHALLING
2543 GenerateArg(Consumer, OPT_diagnostic_serialized_file,
2546 if (Opts.ShowColors)
2549 if (Opts.VerifyDiagnostics &&
2554 if (Prefix !=
"expected")
2561 GenerateArg(Consumer, OPT_verify_ignore_unexpected);
2564 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"note");
2566 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"remark");
2568 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"warning");
2570 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"error");
2575 if (
Warning ==
"undef-prefix")
2578 if (
Warning ==
"invalid-constexpr" ||
Warning ==
"no-invalid-constexpr")
2580 Consumer(StringRef(
"-W") +
Warning);
2586 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2587 "pass-analysis",
"no-pass-analysis",
2588 "pass-missed",
"no-pass-missed"};
2589 if (llvm::is_contained(IgnoredRemarks,
Remark))
2592 Consumer(StringRef(
"-R") +
Remark);
2596 GenerateArg(Consumer, OPT_warning_suppression_mappings_EQ,
2601std::unique_ptr<DiagnosticOptions>
2603 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2604 unsigned MissingArgIndex, MissingArgCount;
2606 Argv.slice(1), MissingArgIndex, MissingArgCount);
2609 if (std::optional<std::string> NoColor =
2610 llvm::sys::Process::GetEnv(
"NO_COLOR");
2611 NoColor && !NoColor->empty()) {
2626 bool DefaultDiagColor) {
2627 std::optional<DiagnosticsEngine> IgnoringDiags;
2631 Diags = &*IgnoringDiags;
2640#define DIAG_OPTION_WITH_MARSHALLING(...) \
2641 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2642#include "clang/Driver/Options.inc"
2643#undef DIAG_OPTION_WITH_MARSHALLING
2645 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2648 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2652 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2654 if (Args.hasArg(OPT_verify))
2659 Opts.VerifyDiagnostics =
false;
2664 "-verify-ignore-unexpected=",
2665 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2666 if (Args.hasArg(OPT_verify_ignore_unexpected))
2668 Opts.setVerifyIgnoreUnexpected(DiagMask);
2670 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2675 if (
const Arg *A = Args.getLastArg(OPT_warning_suppression_mappings_EQ))
2689 std::string &BlockName,
2690 unsigned &MajorVersion,
2691 unsigned &MinorVersion,
2693 std::string &UserInfo) {
2695 Arg.split(Args,
':', 5);
2696 if (Args.size() < 5)
2699 BlockName = std::string(Args[0]);
2700 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2701 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2702 if (Args[3].getAsInteger(2, Hashed))
return true;
2703 if (Args.size() > 4)
2704 UserInfo = std::string(Args[4]);
2713 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2744 OPT_emit_reduced_module_interface},
2762 OPT_print_dependency_directives_minimized_source},
2769static std::optional<frontend::ActionKind>
2772 if (ActionOpt.second == Opt.getID())
2773 return ActionOpt.first;
2775 return std::nullopt;
2779static std::optional<OptSpecifier>
2782 if (ActionOpt.first == ProgramAction)
2783 return OptSpecifier(ActionOpt.second);
2785 return std::nullopt;
2791#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2792 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2793#include "clang/Driver/Options.inc"
2794#undef FRONTEND_OPTION_WITH_MARSHALLING
2796 std::optional<OptSpecifier> ProgramActionOpt =
2800 std::function<void()> GenerateProgramAction = [&]() {
2804 if (!ProgramActionOpt) {
2807 "Frontend action without option.");
2808 GenerateProgramAction = [&]() {
2815 GenerateProgramAction = [&]() {
2823 llvm_unreachable(
"Default AST dump format.");
2830 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);
2843 GenerateProgramAction = [&]() {
2848 GenerateProgramAction();
2850 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2852 for (
const auto &PluginArg : PluginArgs.second)
2854 Opt.getPrefix() + Opt.getName() + PluginArgs.first,
2855 Opt.getKind(), 0, PluginArg);
2859 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2860 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());
2866 for (
const auto &Plugin : Opts.
Plugins)
2872 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);
2879 GenerateArg(Consumer, OPT_aux_target_feature, Feature);
2885 StringRef HeaderUnit =
"";
2890 HeaderUnit =
"-user";
2893 HeaderUnit =
"-system";
2896 HeaderUnit =
"-header-unit";
2899 StringRef Header = IsHeader ?
"-header" :
"";
2922 Lang =
"objective-c";
2925 Lang =
"objective-c++";
2928 Lang =
"assembler-with-cpp";
2932 "Generating -x argument for unknown language (not precompiled).");
2947 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed);
2951 for (
const auto &Input : Opts.
Inputs)
2952 Consumer(Input.getFile());
2961#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2962 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2963#include "clang/Driver/Options.inc"
2964#undef FRONTEND_OPTION_WITH_MARSHALLING
2967 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2968 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2970 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2973 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2974 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2977 .Default(std::numeric_limits<unsigned>::max());
2979 if (Val != std::numeric_limits<unsigned>::max())
2982 Diags.
Report(diag::err_drv_invalid_value)
2983 << A->getAsString(Args) << A->getValue();
2993 Args.hasArg(OPT_interface_stub_version_EQ)
2994 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2996 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2997 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2998 ArgStr ==
"experimental-tapi-elf-v1") {
2999 std::string ErrorMessage =
3000 "Invalid interface stub format: " + ArgStr.str() +
3002 Diags.
Report(diag::err_drv_invalid_value)
3003 <<
"Must specify a valid interface stub format type, ie: "
3004 "-interface-stub-version=ifs-v1"
3007 }
else if (!ArgStr.starts_with(
"ifs-")) {
3008 std::string ErrorMessage =
3009 "Invalid interface stub format: " + ArgStr.str() +
".";
3010 Diags.
Report(diag::err_drv_invalid_value)
3011 <<
"Must specify a valid interface stub format type, ie: "
3012 "-interface-stub-version=ifs-v1"
3027 if (!A->getSpelling().starts_with(
"-ast-dump")) {
3028 const Arg *SavedAction =
nullptr;
3029 for (
const Arg *AA :
3030 Args.filtered(OPT_Action_Group, OPT_main_file_name)) {
3031 if (AA->getOption().matches(OPT_main_file_name)) {
3032 SavedAction =
nullptr;
3033 }
else if (!SavedAction) {
3036 if (!A->getOption().matches(OPT_ast_dump_EQ))
3037 Diags.
Report(diag::err_fe_invalid_multiple_actions)
3038 << SavedAction->getSpelling() << A->getSpelling();
3045 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
3046 Opts.
Plugins.emplace_back(A->getValue(0));
3050 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
3051 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
3053 for (
const std::string &Arg :
3054 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
3055 std::string BlockName;
3056 unsigned MajorVersion;
3057 unsigned MinorVersion;
3059 std::string UserInfo;
3061 MinorVersion, Hashed, UserInfo)) {
3062 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
3069 std::make_shared<TestModuleFileExtension>(
3070 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
3073 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
3077 Diags.
Report(diag::err_drv_invalid_value)
3078 << A->getAsString(Args) << A->getValue();
3081 Opts.
Plugins = Args.getAllArgValues(OPT_load);
3082 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
3083 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
3085 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3086 StringRef Val = A->getValue();
3087 if (!Val.contains(
'='))
3092 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
3094 if (Args.hasArg(OPT_fclangir) || Args.hasArg(OPT_emit_cir))
3097 if (Args.hasArg(OPT_aux_target_cpu))
3098 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
3099 if (Args.hasArg(OPT_aux_target_feature))
3104 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3105 <<
"ARC migration" <<
"ObjC migration";
3109 if (
const Arg *A = Args.getLastArg(OPT_x)) {
3110 StringRef XValue = A->getValue();
3115 bool Preprocessed = XValue.consume_back(
"-cpp-output");
3116 bool ModuleMap = XValue.consume_back(
"-module-map");
3119 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
3125 if (IsHeader || Preprocessed) {
3126 if (XValue.consume_back(
"-header-unit"))
3128 else if (XValue.consume_back(
"-system"))
3130 else if (XValue.consume_back(
"-user"))
3136 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
3140 DashX = llvm::StringSwitch<InputKind>(XValue)
3156 DashX = llvm::StringSwitch<InputKind>(XValue)
3164 DashX = llvm::StringSwitch<InputKind>(XValue)
3167 .Cases(
"ast",
"pcm",
"precompiled-header",
3174 Diags.
Report(diag::err_drv_invalid_value)
3175 << A->getAsString(Args) << A->getValue();
3182 IsHeaderFile =
true;
3183 }
else if (IsHeaderFile)
3190 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
3193 Inputs.push_back(
"-");
3197 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
3199 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
3203 StringRef(Inputs[i]).rsplit(
'.').second);
3212 bool IsSystem =
false;
3221 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
3231 std::string ClangExecutable =
3232 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
3239#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3240 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3241#include "clang/Driver/Options.inc"
3242#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3257 GenerateArg(Consumer, OPT_fmodules_ignore_macro, Macro.val());
3261 std::optional<bool> IsFramework,
3262 std::optional<bool> IgnoreSysRoot) {
3263 return llvm::is_contained(Groups, Entry.
Group) &&
3264 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
3265 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
3274 OptSpecifier Opt = [It, Matches]() {
3279 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
3293 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3300 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3306 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3311 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);
3319 GenerateArg(Consumer, OPT_objc_isystem, It->Path);
3321 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);
3331 ? OPT_internal_isystem
3332 : OPT_internal_externc_isystem;
3336 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3340 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3341 : OPT_no_system_header_prefix;
3351 const std::string &WorkingDir) {
3356#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3357 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3358#include "clang/Driver/Options.inc"
3359#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3361 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3362 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3366 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3367 if (WorkingDir.empty())
3368 llvm::sys::fs::make_absolute(
P);
3370 llvm::sys::fs::make_absolute(WorkingDir,
P);
3372 llvm::sys::path::remove_dots(
P);
3376 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3377 StringRef Val = A->getValue();
3378 if (Val.contains(
'=')) {
3379 auto Split = Val.split(
'=');
3381 std::string(Split.first), std::string(Split.second));
3384 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3387 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3388 StringRef MacroDef = A->getValue();
3390 llvm::CachedHashString(MacroDef.split(
'=').first));
3394 bool IsSysrootSpecified =
3395 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3399 auto PrefixHeaderPath = [IsSysrootSpecified,
3400 &Opts](
const llvm::opt::Arg *A,
3401 bool IsFramework =
false) -> std::string {
3402 assert(A->getNumValues() &&
"Unexpected empty search path flag!");
3403 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3405 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3406 llvm::StringRef(A->getValue()).substr(1));
3407 return std::string(Buffer);
3409 return A->getValue();
3412 for (
const auto *A : Args.filtered(OPT_I, OPT_F)) {
3413 bool IsFramework = A->getOption().matches(OPT_F);
3419 StringRef Prefix =
"";
3420 for (
const auto *A :
3421 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3422 if (A->getOption().matches(OPT_iprefix))
3423 Prefix = A->getValue();
3424 else if (A->getOption().matches(OPT_iwithprefix))
3430 for (
const auto *A : Args.filtered(OPT_idirafter))
3432 for (
const auto *A : Args.filtered(OPT_iquote))
3435 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {
3436 if (A->getOption().matches(OPT_iwithsysroot)) {
3443 for (
const auto *A : Args.filtered(OPT_iframework))
3445 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3450 for (
const auto *A : Args.filtered(OPT_c_isystem))
3452 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3454 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3456 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3460 for (
const auto *A :
3461 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3463 if (A->getOption().matches(OPT_internal_externc_isystem))
3465 Opts.
AddPath(A->getValue(), Group,
false,
true);
3469 for (
const auto *A :
3470 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3472 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3474 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3483 GenerateArg(Consumer, OPT_fapinotes_swift_version,
3492 if (
const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {
3494 diags.
Report(diag::err_drv_invalid_value)
3495 << A->getAsString(Args) << A->getValue();
3497 for (
const Arg *A : Args.filtered(OPT_iapinotes_modules))
3503 if (Opts.PointerAuthIntrinsics)
3505 if (Opts.PointerAuthCalls)
3507 if (Opts.PointerAuthReturns)
3509 if (Opts.PointerAuthIndirectGotos)
3510 GenerateArg(Consumer, OPT_fptrauth_indirect_gotos);
3511 if (Opts.PointerAuthAuthTraps)
3513 if (Opts.PointerAuthVTPtrAddressDiscrimination)
3514 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_address_discrimination);
3515 if (Opts.PointerAuthVTPtrTypeDiscrimination)
3516 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_type_discrimination);
3517 if (Opts.PointerAuthTypeInfoVTPtrDiscrimination)
3518 GenerateArg(Consumer, OPT_fptrauth_type_info_vtable_pointer_discrimination);
3519 if (Opts.PointerAuthFunctionTypeDiscrimination)
3520 GenerateArg(Consumer, OPT_fptrauth_function_pointer_type_discrimination);
3521 if (Opts.PointerAuthInitFini)
3523 if (Opts.PointerAuthInitFiniAddressDiscrimination)
3524 GenerateArg(Consumer, OPT_fptrauth_init_fini_address_discrimination);
3525 if (Opts.PointerAuthELFGOT)
3527 if (Opts.AArch64JumpTableHardening)
3528 GenerateArg(Consumer, OPT_faarch64_jump_table_hardening);
3533 Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);
3534 Opts.PointerAuthCalls = Args.hasArg(OPT_fptrauth_calls);
3535 Opts.PointerAuthReturns = Args.hasArg(OPT_fptrauth_returns);
3536 Opts.PointerAuthIndirectGotos = Args.hasArg(OPT_fptrauth_indirect_gotos);
3537 Opts.PointerAuthAuthTraps = Args.hasArg(OPT_fptrauth_auth_traps);
3538 Opts.PointerAuthVTPtrAddressDiscrimination =
3539 Args.hasArg(OPT_fptrauth_vtable_pointer_address_discrimination);
3540 Opts.PointerAuthVTPtrTypeDiscrimination =
3541 Args.hasArg(OPT_fptrauth_vtable_pointer_type_discrimination);
3542 Opts.PointerAuthTypeInfoVTPtrDiscrimination =
3543 Args.hasArg(OPT_fptrauth_type_info_vtable_pointer_discrimination);
3544 Opts.PointerAuthFunctionTypeDiscrimination =
3545 Args.hasArg(OPT_fptrauth_function_pointer_type_discrimination);
3546 Opts.PointerAuthInitFini = Args.hasArg(OPT_fptrauth_init_fini);
3547 Opts.PointerAuthInitFiniAddressDiscrimination =
3548 Args.hasArg(OPT_fptrauth_init_fini_address_discrimination);
3549 Opts.PointerAuthELFGOT = Args.hasArg(OPT_fptrauth_elf_got);
3550 Opts.AArch64JumpTableHardening =
3551 Args.hasArg(OPT_faarch64_jump_table_hardening);
3561 llvm_unreachable(
"should not parse language flags for this input");
3596 llvm_unreachable(
"unexpected input language");
3605 return "Objective-C";
3609 return "Objective-C++";
3613 return "C++ for OpenCL";
3632 llvm_unreachable(
"unknown input language");
3635void CompilerInvocationBase::GenerateLangArgs(
const LangOptions &Opts,
3637 const llvm::Triple &
T,
3642 if (Opts.ObjCAutoRefCount)
3644 if (Opts.PICLevel != 0)
3645 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));
3649 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3654 OptSpecifier StdOpt;
3656 case LangStandard::lang_opencl10:
3657 case LangStandard::lang_opencl11:
3658 case LangStandard::lang_opencl12:
3659 case LangStandard::lang_opencl20:
3660 case LangStandard::lang_opencl30:
3661 case LangStandard::lang_openclcpp10:
3662 case LangStandard::lang_openclcpp2021:
3663 StdOpt = OPT_cl_std_EQ;
3666 StdOpt = OPT_std_EQ;
3673 if (Opts.IncludeDefaultHeader)
3674 GenerateArg(Consumer, OPT_finclude_default_header);
3675 if (Opts.DeclareOpenCLBuiltins)
3676 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);
3680#define LANG_OPTION_WITH_MARSHALLING(...) \
3681 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3682#include "clang/Driver/Options.inc"
3683#undef LANG_OPTION_WITH_MARSHALLING
3694 else if (Opts.ObjCAutoRefCount == 1)
3697 if (Opts.ObjCWeakRuntime)
3698 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);
3703 if (Opts.ObjCSubscriptingLegacyRuntime)
3704 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);
3707 if (Opts.GNUCVersion != 0) {
3708 unsigned Major = Opts.GNUCVersion / 100 / 100;
3709 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3710 unsigned Patch = Opts.GNUCVersion % 100;
3712 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch));
3715 if (Opts.IgnoreXCOFFVisibility)
3716 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);
3725 if (Opts.MSCompatibilityVersion != 0) {
3726 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3727 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3728 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3729 GenerateArg(Consumer, OPT_fms_compatibility_version,
3730 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor));
3733 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3735 if (!Opts.Trigraphs)
3742 if (
T.isOSzOS() && !Opts.ZOSExt)
3744 else if (Opts.ZOSExt)
3747 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3750 if (Opts.ConvergentFunctions)
3753 GenerateArg(Consumer, OPT_fno_convergent_functions);
3755 if (Opts.NoBuiltin && !Opts.Freestanding)
3758 if (!Opts.NoBuiltin)
3762 if (Opts.LongDoubleSize == 128)
3764 else if (Opts.LongDoubleSize == 64)
3766 else if (Opts.LongDoubleSize == 80)
3773 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3776 if (Opts.OpenMP != 51)
3777 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3779 if (!Opts.OpenMPUseTLS)
3782 if (Opts.OpenMPIsTargetDevice)
3783 GenerateArg(Consumer, OPT_fopenmp_is_target_device);
3785 if (Opts.OpenMPIRBuilder)
3786 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);
3789 if (Opts.OpenMPSimd) {
3792 if (Opts.OpenMP != 51)
3793 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3796 if (Opts.OpenMPThreadSubscription)
3797 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);
3799 if (Opts.OpenMPTeamSubscription)
3800 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);
3802 if (Opts.OpenMPTargetDebug != 0)
3803 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,
3804 Twine(Opts.OpenMPTargetDebug));
3806 if (Opts.OpenMPCUDANumSMs != 0)
3807 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,
3808 Twine(Opts.OpenMPCUDANumSMs));
3810 if (Opts.OpenMPCUDABlocksPerSM != 0)
3811 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3812 Twine(Opts.OpenMPCUDABlocksPerSM));
3814 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3815 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3816 Twine(Opts.OpenMPCUDAReductionBufNum));
3819 std::string Targets;
3820 llvm::raw_string_ostream OS(Targets);
3823 [&OS](
const llvm::Triple &
T) { OS << T.str(); },
",");
3824 GenerateArg(Consumer, OPT_fopenmp_targets_EQ, Targets);
3830 if (Opts.OpenMPCUDAMode)
3850 GenerateArg(Consumer, OPT_ffp_contract,
"fast-honor-pragmas");
3853 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3857 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
3859 switch (Opts.getClangABICompat()) {
3861 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"3.8");
3864 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"4.0");
3867 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"6.0");
3870 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"7.0");
3873 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"9.0");
3876 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"11.0");
3879 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"12.0");
3882 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"14.0");
3885 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"15.0");
3888 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"17.0");
3891 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"18.0");
3894 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"19.0");
3900 if (Opts.getSignReturnAddressScope() ==
3902 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"all");
3903 else if (Opts.getSignReturnAddressScope() ==
3905 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"non-leaf");
3907 if (Opts.getSignReturnAddressKey() ==
3909 GenerateArg(Consumer, OPT_msign_return_address_key_EQ,
"b_key");
3915 if (Opts.RelativeCXXABIVTables)
3916 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);
3918 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);
3926 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second);
3932bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3934 std::vector<std::string> &Includes,
3944 if (Args.hasArg(OPT_fobjc_arc))
3945 Opts.ObjCAutoRefCount = 1;
3949 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3961 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3964 Diags.
Report(diag::err_drv_invalid_value)
3965 << A->getAsString(Args) << A->getValue();
3967 for (
unsigned KindValue = 0;
3973 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3974 Diag <<
Std.getName() <<
Std.getDescription();
3975 unsigned NumAliases = 0;
3976#define LANGSTANDARD(id, name, lang, desc, features)
3977#define LANGSTANDARD_ALIAS(id, alias) \
3978 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3979#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3980#include "clang/Basic/LangStandards.def"
3982#define LANGSTANDARD(id, name, lang, desc, features)
3983#define LANGSTANDARD_ALIAS(id, alias) \
3984 if (KindValue == LangStandard::lang_##id) Diag << alias;
3985#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3986#include "clang/Basic/LangStandards.def"
3994 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4002 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
4004 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
4005 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
4006 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
4007 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
4008 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
4009 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
4010 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
4011 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
4012 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
4013 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
4017 Diags.
Report(diag::err_drv_invalid_value)
4018 << A->getAsString(Args) << A->getValue();
4021 LangStd = OpenCLLangStd;
4025 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
4026 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
4034#define LANG_OPTION_WITH_MARSHALLING(...) \
4035 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4036#include "clang/Driver/Options.inc"
4037#undef LANG_OPTION_WITH_MARSHALLING
4039 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4040 StringRef Name = A->getValue();
4041 if (Name ==
"full" || Name ==
"branch") {
4042 Opts.CFProtectionBranch = 1;
4046 if (Opts.CFProtectionBranch) {
4047 if (
const Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {
4049 llvm::StringSwitch<CFBranchLabelSchemeKind>(A->getValue())
4050#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \
4051 .Case(#FlagVal, CFBranchLabelSchemeKind::Kind)
4052#include "clang/Basic/CFProtectionOptions.def"
4054 Opts.setCFBranchLabelScheme(Scheme);
4058 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
4059 !Args.hasArg(OPT_sycl_std_EQ)) {
4069 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
4070 StringRef value =
arg->getValue();
4072 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
4075 if (Args.hasArg(OPT_fobjc_gc_only))
4077 else if (Args.hasArg(OPT_fobjc_gc))
4079 else if (Args.hasArg(OPT_fobjc_arc)) {
4080 Opts.ObjCAutoRefCount = 1;
4082 Diags.
Report(diag::err_arc_unsupported_on_runtime);
4089 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
4090 Opts.ObjCWeakRuntime = 1;
4096 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
4097 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
4098 assert(!Opts.ObjCWeak);
4100 Diags.
Report(diag::err_objc_weak_with_gc);
4101 }
else if (!Opts.ObjCWeakRuntime) {
4102 Diags.
Report(diag::err_objc_weak_unsupported);
4106 }
else if (Opts.ObjCAutoRefCount) {
4107 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
4110 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
4111 Opts.ObjCSubscriptingLegacyRuntime =
4115 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
4118 VersionTuple GNUCVer;
4119 bool Invalid = GNUCVer.tryParse(A->getValue());
4120 unsigned Major = GNUCVer.getMajor();
4121 unsigned Minor = GNUCVer.getMinor().value_or(0);
4122 unsigned Patch = GNUCVer.getSubminor().value_or(0);
4123 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
4124 Diags.
Report(diag::err_drv_invalid_value)
4125 << A->getAsString(Args) << A->getValue();
4127 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
4130 if (
T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
4131 Opts.IgnoreXCOFFVisibility = 1;
4133 if (Args.hasArg(OPT_ftrapv)) {
4137 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
4139 else if (Args.hasArg(OPT_fwrapv))
4142 Opts.MSCompatibilityVersion = 0;
4143 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
4145 if (VT.tryParse(A->getValue()))
4146 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
4148 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
4149 VT.getMinor().value_or(0) * 100000 +
4150 VT.getSubminor().value_or(0);
4158 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
4161 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
4164 Args.hasFlag(OPT_fzos_extensions, OPT_fno_zos_extensions,
T.isOSzOS());
4166 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
4167 && Opts.OpenCLVersion == 200);
4169 bool HasConvergentOperations = Opts.OpenMPIsTargetDevice || Opts.OpenCL ||
4170 Opts.CUDAIsDevice || Opts.SYCLIsDevice ||
4171 Opts.HLSL ||
T.isAMDGPU() ||
T.isNVPTX();
4172 Opts.ConvergentFunctions =
4173 Args.hasFlag(OPT_fconvergent_functions, OPT_fno_convergent_functions,
4174 HasConvergentOperations);
4176 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
4177 if (!Opts.NoBuiltin)
4179 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
4180 if (A->getOption().matches(options::OPT_mlong_double_64))
4181 Opts.LongDoubleSize = 64;
4182 else if (A->getOption().matches(options::OPT_mlong_double_80))
4183 Opts.LongDoubleSize = 80;
4184 else if (A->getOption().matches(options::OPT_mlong_double_128))
4185 Opts.LongDoubleSize = 128;
4187 Opts.LongDoubleSize = 0;
4189 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
4195 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
4197 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4198 << A->getSpelling() <<
"-fdefault-calling-conv";
4200 switch (
T.getArch()) {
4201 case llvm::Triple::x86:
4204 case llvm::Triple::m68k:
4208 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4209 << A->getSpelling() <<
T.getTriple();
4215 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;
4217 bool IsSimdSpecified =
4218 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
4220 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
4222 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
4223 Opts.OpenMPIsTargetDevice =
4224 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);
4225 Opts.OpenMPIRBuilder =
4226 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
4227 bool IsTargetSpecified =
4228 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
4230 if (Opts.OpenMP || Opts.OpenMPSimd) {
4232 Args, OPT_fopenmp_version_EQ,
4233 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))
4234 Opts.OpenMP = Version;
4237 if (!Opts.OpenMPIsTargetDevice) {
4238 switch (
T.getArch()) {
4242 case llvm::Triple::nvptx:
4243 case llvm::Triple::nvptx64:
4244 Diags.
Report(diag::err_drv_omp_host_target_not_supported) <<
T.str();
4252 if ((Opts.OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN())) ||
4253 Opts.OpenCLCPlusPlus) {
4255 Opts.Exceptions = 0;
4256 Opts.CXXExceptions = 0;
4258 if (Opts.OpenMPIsTargetDevice &&
T.isNVPTX()) {
4259 Opts.OpenMPCUDANumSMs =
4261 Opts.OpenMPCUDANumSMs, Diags);
4262 Opts.OpenMPCUDABlocksPerSM =
4264 Opts.OpenMPCUDABlocksPerSM, Diags);
4266 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
4267 Opts.OpenMPCUDAReductionBufNum, Diags);
4272 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
4273 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
4275 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
4276 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
4277 Opts.OpenMPTargetDebug = 1;
4280 if (Opts.OpenMPIsTargetDevice) {
4281 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
4282 Opts.OpenMPTeamSubscription =
true;
4283 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
4284 Opts.OpenMPThreadSubscription =
true;
4288 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
4289 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
4290 auto getArchPtrSize = [](
const llvm::Triple &
T) {
4291 if (
T.isArch16Bit())
4293 if (
T.isArch32Bit())
4295 assert(
T.isArch64Bit() &&
"Expected 64-bit architecture");
4299 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
4300 llvm::Triple TT(A->getValue(i));
4302 if (TT.getArch() == llvm::Triple::UnknownArch ||
4303 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
4304 TT.getArch() == llvm::Triple::spirv64 ||
4305 TT.getArch() == llvm::Triple::systemz ||
4306 TT.getArch() == llvm::Triple::loongarch64 ||
4307 TT.getArch() == llvm::Triple::nvptx ||
4308 TT.getArch() == llvm::Triple::nvptx64 ||
4309 TT.getArch() == llvm::Triple::amdgcn ||
4310 TT.getArch() == llvm::Triple::x86 ||
4311 TT.getArch() == llvm::Triple::x86_64))
4312 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
4313 else if (getArchPtrSize(
T) != getArchPtrSize(TT))
4314 Diags.
Report(diag::err_drv_incompatible_omp_arch)
4315 << A->getValue(i) <<
T.str();
4323 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
4326 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
4331 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&
4332 (
T.isNVPTX() ||
T.isAMDGCN()) &&
4333 Args.hasArg(options::OPT_fopenmp_cuda_mode);
4336 if (Args.hasArg(options::OPT_fopenacc)) {
4337 Opts.OpenACC =
true;
4339 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override))
4346 Opts.Optimize = Opt != 0;
4347 Opts.OptimizeSize = OptSize != 0;
4352 Opts.NoInlineDefine = !Opts.Optimize;
4353 if (Arg *InlineArg = Args.getLastArg(
4354 options::OPT_finline_functions, options::OPT_finline_hint_functions,
4355 options::OPT_fno_inline_functions, options::OPT_fno_inline))
4356 if (InlineArg->getOption().matches(options::OPT_fno_inline))
4357 Opts.NoInlineDefine =
true;
4359 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
4360 StringRef Val = A->getValue();
4363 else if (Val ==
"on")
4365 else if (Val ==
"off")
4367 else if (Val ==
"fast-honor-pragmas")
4370 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
4374 Args.getLastArg(OPT_fsanitize_undefined_ignore_overflow_pattern_EQ)) {
4375 for (
int i = 0, n = A->getNumValues(); i != n; ++i) {
4377 llvm::StringSwitch<unsigned>(A->getValue(i))
4380 .Case(
"add-unsigned-overflow-test",
4382 .Case(
"add-signed-overflow-test",
4385 .Case(
"unsigned-post-decr-while",
4394 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
4395 std::vector<std::string> systemIgnorelists =
4396 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
4398 systemIgnorelists.begin(),
4399 systemIgnorelists.end());
4401 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
4404 StringRef Ver = A->getValue();
4405 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
4406 unsigned Major, Minor = 0;
4410 if (!VerParts.first.starts_with(
"0") &&
4411 !VerParts.first.getAsInteger(10, Major) && 3 <= Major &&
4412 Major <= CLANG_VERSION_MAJOR &&
4414 ? VerParts.second.size() == 1 &&
4415 !VerParts.second.getAsInteger(10, Minor)
4416 : VerParts.first.size() == Ver.size() || VerParts.second ==
"0")) {
4418 if (Major == 3 && Minor <= 8)
4420 else if (Major <= 4)
4422 else if (Major <= 6)
4424 else if (Major <= 7)
4426 else if (Major <= 9)
4428 else if (Major <= 11)
4430 else if (Major <= 12)
4432 else if (Major <= 14)
4434 else if (Major <= 15)
4436 else if (Major <= 17)
4438 else if (Major <= 18)
4440 else if (Major <= 19)
4442 }
else if (Ver !=
"latest") {
4443 Diags.
Report(diag::err_drv_invalid_value)
4444 << A->getAsString(Args) << A->getValue();
4448 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4449 StringRef SignScope = A->getValue();
4451 if (SignScope.equals_insensitive(
"none"))
4452 Opts.setSignReturnAddressScope(
4454 else if (SignScope.equals_insensitive(
"all"))
4455 Opts.setSignReturnAddressScope(
4457 else if (SignScope.equals_insensitive(
"non-leaf"))
4458 Opts.setSignReturnAddressScope(
4461 Diags.
Report(diag::err_drv_invalid_value)
4462 << A->getAsString(Args) << SignScope;
4464 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4465 StringRef SignKey = A->getValue();
4466 if (!SignScope.empty() && !SignKey.empty()) {
4467 if (SignKey ==
"a_key")
4468 Opts.setSignReturnAddressKey(
4470 else if (SignKey ==
"b_key")
4471 Opts.setSignReturnAddressKey(
4474 Diags.
Report(diag::err_drv_invalid_value)
4475 << A->getAsString(Args) << SignKey;
4481 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4488 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI <<
T.str();
4494 Opts.RelativeCXXABIVTables =
4495 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4496 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4500 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);
4501 Opts.OmitVTableRTTI =
4502 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
4503 options::OPT_fno_experimental_omit_vtable_rtti,
false);
4504 if (Opts.OmitVTableRTTI && HasRTTI)
4505 Diags.
Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
4507 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4508 auto Split = StringRef(A).split(
'=');
4510 {std::string(
Split.first), std::string(
Split.second)});
4514 !Args.getLastArg(OPT_fno_file_reproducible) &&
4515 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4516 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4517 Args.getLastArg(OPT_ffile_reproducible));
4520 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4522 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4523 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4526 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4527 std::ifstream SeedFile(A->getValue(0));
4529 if (!SeedFile.is_open())
4530 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4536 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4543 if (
T.isDXIL() ||
T.isSPIRVLogical()) {
4545 enum { OS, Environment };
4547 int ExpectedOS =
T.isSPIRVLogical() ? VulkanEnv : ShaderModel;
4549 if (
T.getOSName().empty()) {
4550 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4551 << ExpectedOS << OS <<
T.str();
4552 }
else if (
T.getEnvironmentName().empty()) {
4553 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4555 }
else if (!
T.isShaderStageEnvironment()) {
4556 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4561 if (!
T.isShaderModelOS() ||
T.getOSVersion() == VersionTuple(0)) {
4562 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4563 << ShaderModel <<
T.getOSName() <<
T.str();
4568 if (Args.getLastArg(OPT_fnative_half_type)) {
4571 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018 &&
4572 T.getOSVersion() >= VersionTuple(6, 2)))
4573 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4574 <<
"-enable-16bit-types" <<
true <<
Std.getName()
4575 <<
T.getOSVersion().getAsString();
4577 }
else if (
T.isSPIRVLogical()) {
4578 if (!
T.isVulkanOS() ||
T.getVulkanVersion() == VersionTuple(0)) {
4579 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4580 << VulkanEnv <<
T.getOSName() <<
T.str();
4582 if (Args.getLastArg(OPT_fnative_half_type)) {
4585 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018))
4586 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4587 <<
"-fnative-half-type" <<
false <<
Std.getName();
4590 llvm_unreachable(
"expected DXIL or SPIR-V target");
4593 Diags.
Report(diag::err_drv_hlsl_unsupported_target) <<
T.str();
4595 if (Opts.
LangStd < LangStandard::lang_hlsl202x) {
4600 Diags.
Report(diag::warn_hlsl_langstd_minimal)
4652 llvm_unreachable(
"invalid frontend action");
4662#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4663 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4664#include "clang/Driver/Options.inc"
4665#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4668 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);
4671 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl,
D);
4678 for (
const auto &M : Opts.
Macros) {
4681 if (M.first ==
"__CET__=1" && !M.second &&
4682 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4684 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4685 !CodeGenOpts.CFProtectionBranch)
4687 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4688 CodeGenOpts.CFProtectionBranch)
4691 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);
4694 for (
const auto &I : Opts.
Includes) {
4697 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4698 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4703 if (LangOpts.HLSL && I ==
"hlsl.h")
4713 GenerateArg(Consumer, OPT_remap_file, RF.first +
";" + RF.second);
4719 GenerateArg(Consumer, OPT_fdefine_target_os_macros);
4722 GenerateArg(Consumer, OPT_embed_dir_EQ, EmbedEntry);
4736#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4737 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4738#include "clang/Driver/Options.inc"
4739#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4741 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4742 Args.hasArg(OPT_pch_through_hdrstop_use);
4744 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4747 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4748 StringRef
Value(A->getValue());
4749 size_t Comma =
Value.find(
',');
4751 unsigned EndOfLine = 0;
4753 if (Comma == StringRef::npos ||
4754 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4755 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4756 Diags.
Report(diag::err_drv_preamble_format);
4764 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4765 StringRef Name = A->getValue();
4766 if (Name ==
"branch")
4768 else if (Name ==
"return")
4770 else if (Name ==
"full")
4775 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4776 if (A->getOption().matches(OPT_D))
4783 for (
const auto *A : Args.filtered(OPT_include))
4784 Opts.
Includes.emplace_back(A->getValue());
4786 for (
const auto *A : Args.filtered(OPT_chain_include))
4789 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4790 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4792 if (Split.second.empty()) {
4793 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4800 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4801 StringRef Epoch = A->getValue();
4805 const uint64_t MaxTimestamp =
4806 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4808 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4809 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4810 << Epoch << MaxTimestamp;
4816 for (
const auto *A : Args.filtered(OPT_embed_dir_EQ)) {
4817 StringRef Val = A->getValue();
4828 Args.hasFlag(OPT_fdefine_target_os_macros,
4840#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4841 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4842#include "clang/Driver/Options.inc"
4843#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4861#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4862 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4863#include "clang/Driver/Options.inc"
4864#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4867 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4876#define TARGET_OPTION_WITH_MARSHALLING(...) \
4877 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4878#include "clang/Driver/Options.inc"
4879#undef TARGET_OPTION_WITH_MARSHALLING
4885 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,
4895#define TARGET_OPTION_WITH_MARSHALLING(...) \
4896 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4897#include "clang/Driver/Options.inc"
4898#undef TARGET_OPTION_WITH_MARSHALLING
4900 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4901 llvm::VersionTuple Version;
4902 if (Version.tryParse(A->getValue()))
4903 Diags.
Report(diag::err_drv_invalid_value)
4904 << A->getAsString(Args) << A->getValue();
4909 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4910 llvm::VersionTuple Version;
4911 if (Version.tryParse(A->getValue()))
4912 Diags.
Report(diag::err_drv_invalid_value)
4913 << A->getAsString(Args) << A->getValue();
4921bool CompilerInvocation::CreateFromArgsImpl(
4929 unsigned MissingArgIndex, MissingArgCount;
4930 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4931 MissingArgCount, VisibilityMask);
4935 if (MissingArgCount)
4936 Diags.
Report(diag::err_drv_missing_argument)
4937 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4940 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4941 auto ArgString = A->getAsString(Args);
4942 std::string Nearest;
4943 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)
4944 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4946 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4947 << ArgString << Nearest;
4996 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4997 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4998 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4999 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
5012 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
5018 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
5032 Diags, llvm::vfs::getRealFileSystem());
5046 const char *Argv0) {
5052 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
5056 Args.push_back(
"-cc1");
5059 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
5064 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;
5077#define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
5078#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5079 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
5080#define BENIGN_LANGOPT(Name, Bits, Default, Description)
5081#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
5082#include "clang/Basic/LangOptions.def"
5087 HBuilder.addRange(
getLangOpts().CommentOpts.BlockCommandNames);
5104 StringRef MacroDef = Macro.first;
5106 llvm::CachedHashString(MacroDef.split(
'=').first)))
5110 HBuilder.add(Macro);
5126#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
5127#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5128 HBuilder.add(diagOpts.get##Name());
5129#include "clang/Basic/DiagnosticOptions.def"
5139 ext->hashExtension(HBuilder);
5146 HBuilder.add(*Minor);
5147 if (
auto Subminor =
APINotesOpts.SwiftVersion.getSubminor())
5148 HBuilder.add(*Subminor);
5150 HBuilder.add(*Build);
5160#define DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
5161#define VALUE_DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
5162#define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
5163 HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
5164#define BENIGN_DEBUGOPT(Name, Bits, Default)
5165#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
5166#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
5167#include "clang/Basic/DebugOptions.def"
5174 if (!SanHash.
empty())
5175 HBuilder.add(SanHash.
Mask);
5177 llvm::MD5::MD5Result
Result;
5178 HBuilder.getHasher().final(
Result);
5180 return toString(llvm::APInt(64, Hash), 36,
false);
5208 std::vector<std::string> Args{
"-cc1"};
5210 [&Args](
const Twine &Arg) { Args.push_back(Arg.str()); });
5236 llvm::vfs::getRealFileSystem());
5244 Diags, std::move(BaseFS));
5250 if (VFSOverlayFiles.empty())
5255 for (
const auto &
File : VFSOverlayFiles) {
5256 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
5259 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
5264 std::move(Buffer.get()),
nullptr,
File,
5267 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 void parsePointerAuthOptions(PointerAuthOptions &Opts, const LangOptions &LangOpts, const llvm::Triple &Triple, DiagnosticsEngine &Diags)
static void denormalizeString(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, T Value)
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 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 void GeneratePointerAuthArgs(const LangOptions &Opts, ArgumentConsumer Consumer)
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 denormalizeSimpleEnumImpl(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, unsigned Value)
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 ParsePointerAuthArgs(LangOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, DiagnosticsEngine *Diags)
static void denormalizeSimpleFlag(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass, unsigned,...)
The tblgen-erated code passes in a fifth parameter of an arbitrary type, but denormalizeSimpleFlags n...
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 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 SanitizerMaskCutoffs parseSanitizerWeightedKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags)
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 llvm::StringRef lookupStrInTable(unsigned Offset)
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 void denormalizeStringVector(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, const std::vector< std::string > &Values)
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 void denormalizeSimpleEnum(ArgumentConsumer Consumer, unsigned SpellingOffset, Option::OptionClass OptClass, unsigned TableIndex, T Value)
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.
SanitizerSet SanitizeMergeHandlers
Set of sanitizer checks that can merge handlers (smaller code size at the expense of debuggability).
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.
std::string OptRecordPasses
The regex that filters the passes that should be saved to the optimization records.
std::string SaveTempsFilePrefix
Prefix to use for -save-temps output.
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
bool hasSanitizeCoverage() const
PointerAuthOptions PointerAuth
Configuration for pointer-signing.
llvm::DenormalMode FP32DenormalMode
The floating-point denormal mode to use, for float.
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
bool hasReducedDebugInfo() const
Check if type and variable info should be emitted.
OptRemark OptimizationRemark
Selected optimizations for which we should enable optimization remarks.
std::string ThinLTOIndexFile
Name of the function summary index file to use for ThinLTO function importing.
const char * Argv0
Executable and command-line used to create a given CompilerInvocation.
SanitizerMaskCutoffs SanitizeSkipHotCutoffs
Set of thresholds in a range [0.0, 1.0]: the top hottest code responsible for the given fraction of P...
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
OptRemark OptimizationRemarkAnalysis
Selected optimizations for which we should enable optimization analyses.
std::vector< std::string > CommandLineArgs
void resetNonModularOptions(StringRef ModuleFormat)
Reset all of the options that are not considered when building a module.
std::string OptRecordFormat
The format used for serializing remarks (default: YAML)
std::string DIBugsReportFilePath
The file to use for dumping bug report by Debugify for original debug info.
OptRemark OptimizationRemarkMissed
Selected optimizations for which we should enable missed optimization remarks.
The base class of CompilerInvocation.
std::shared_ptr< MigratorOptions > MigratorOpts
std::shared_ptr< PreprocessorOutputOptions > PreprocessorOutputOpts
Options controlling preprocessed output.
std::shared_ptr< APINotesOptions > APINotesOpts
Options controlling API notes.
std::shared_ptr< TargetOptions > TargetOpts
Options controlling the target.
const FrontendOptions & getFrontendOpts() const
const CodeGenOptions & getCodeGenOpts() const
llvm::function_ref< const char *(const Twine &)> StringAllocator
Command line generation.
const FileSystemOptions & getFileSystemOpts() const
std::shared_ptr< PreprocessorOptions > PPOpts
Options controlling the preprocessor (aside from #include handling).
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
std::vector< std::string > getCC1CommandLine() const
Generate cc1-compatible command line arguments from this instance, wrapping the result as a std::vect...
std::shared_ptr< FileSystemOptions > FSOpts
Options controlling file system operations.
const AnalyzerOptions & getAnalyzerOpts() const
const MigratorOptions & getMigratorOpts() const
void generateCC1CommandLine(llvm::SmallVectorImpl< const char * > &Args, StringAllocator SA) const
Generate cc1-compatible command line arguments from this instance.
CompilerInvocationBase & deep_copy_assign(const CompilerInvocationBase &X)
const DependencyOutputOptions & getDependencyOutputOpts() const
AnalyzerOptionsRef AnalyzerOpts
Options controlling the static analyzer.
IntrusiveRefCntPtr< DiagnosticOptions > DiagnosticOpts
Options controlling the diagnostic engine.
CompilerInvocationBase & shallow_copy_assign(const CompilerInvocationBase &X)
const TargetOptions & getTargetOpts() const
std::shared_ptr< CodeGenOptions > CodeGenOpts
Options controlling IRgen and the backend.
std::shared_ptr< LangOptions > LangOpts
Options controlling the language variant.
const APINotesOptions & getAPINotesOpts() const
const HeaderSearchOptions & getHeaderSearchOpts() const
std::shared_ptr< HeaderSearchOptions > HSOpts
Options controlling the #include directive.
const PreprocessorOptions & getPreprocessorOpts() const
const DiagnosticOptions & getDiagnosticOpts() const
const LangOptions & getLangOpts() const
Const getters.
std::shared_ptr< FrontendOptions > FrontendOpts
Options controlling the frontend itself.
llvm::function_ref< void(const Twine &)> ArgumentConsumer
std::shared_ptr< DependencyOutputOptions > DependencyOutputOpts
Options controlling dependency output.
Helper class for holding the data necessary to invoke the compiler.
PreprocessorOptions & getPreprocessorOpts()
void clearImplicitModuleBuildOptions()
Disable implicit modules and canonicalize options that are only used by implicit modules.
MigratorOptions & getMigratorOpts()
AnalyzerOptions & getAnalyzerOpts()
APINotesOptions & getAPINotesOpts()
static std::string GetResourcesPath(const char *Argv0, void *MainAddr)
Get the directory where the compiler headers reside, relative to the compiler binary (found by the pa...
static bool CreateFromArgs(CompilerInvocation &Res, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Create a compiler invocation from a list of input options.
LangOptions & getLangOpts()
Mutable getters.
static bool checkCC1RoundTrip(ArrayRef< const char * > Args, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Check that Args can be parsed and re-serialized without change, emiting diagnostics for any differenc...
DependencyOutputOptions & getDependencyOutputOpts()
CompilerInvocation()=default
void resetNonModularOptions()
Reset all of the options that are not considered when building a module.
FrontendOptions & getFrontendOpts()
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
FileSystemOptions & getFileSystemOpts()
CompilerInvocation & operator=(const CompilerInvocation &X)
static void setDefaultPointerAuthOptions(PointerAuthOptions &Opts, const LangOptions &LangOpts, const llvm::Triple &Triple)
Populate Opts with the default set of pointer authentication-related options given LangOpts and Tripl...
CodeGenOptions & getCodeGenOpts()
std::shared_ptr< LangOptions > LangOpts
Base class internals.
TargetOptions & getTargetOpts()
HeaderSearchOptions & getHeaderSearchOpts()
DiagnosticOptions & getDiagnosticOpts()
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Same as CompilerInvocation, but with copy-on-write optimization.
FrontendOptions & getMutFrontendOpts()
LangOptions & getMutLangOpts()
Mutable getters.
HeaderSearchOptions & getMutHeaderSearchOpts()
MigratorOptions & getMutMigratorOpts()
PreprocessorOptions & getMutPreprocessorOpts()
APINotesOptions & getMutAPINotesOpts()
PreprocessorOutputOptions & getMutPreprocessorOutputOpts()
CodeGenOptions & getMutCodeGenOpts()
TargetOptions & getMutTargetOpts()
FileSystemOptions & getMutFileSystemOpts()
AnalyzerOptions & getMutAnalyzerOpts()
DiagnosticOptions & getMutDiagnosticOpts()
DependencyOutputOptions & getMutDependencyOutputOpts()
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
ShowIncludesDestination ShowIncludesDest
Destination of cl.exe style /showIncludes info.
HeaderIncludeFormatKind HeaderIncludeFormat
The format of header information.
std::string OutputFile
The file to write dependency output to.
HeaderIncludeFilteringKind HeaderIncludeFiltering
Determine whether header information should be filtered.
std::vector< std::string > Targets
A list of names to use as the targets in the dependency file; this list must contain at least one ent...
std::vector< std::pair< std::string, ExtraDepKind > > ExtraDeps
A list of extra dependencies (filename and kind) to be used for every target.
unsigned IncludeSystemHeaders
Include system header dependencies.
Used for handling and querying diagnostic IDs.
Options for controlling the compiler diagnostics engine.
std::string DiagnosticSuppressionMappingsFile
Path for the file that defines diagnostic suppression mappings.
std::vector< std::string > Remarks
The list of -R... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > Warnings
The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > VerifyPrefixes
The prefixes for comment directives sought by -verify ("expected" by default).
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
unsigned getNumErrors() const
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
unsigned getNumWarnings() const
Keeps track of options that affect how file operations are performed.
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
FrontendOptions - Options for controlling the behavior of the frontend.
InputKind DashX
The input kind, either specified via -x argument or deduced from the input file name.
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input.
std::map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
unsigned IsSystemModule
When using -emit-module, treat the modulemap as a system module.
unsigned UseClangIRPipeline
Use Clang IR pipeline to emit code.
ASTDumpOutputFormat ASTDumpFormat
Specifies the output format of the AST.
std::optional< std::string > AuxTargetCPU
Auxiliary target CPU for CUDA/HIP compilation.
std::string OutputFile
The output file, if any.
unsigned ShowStats
Show frontend performance metrics and statistics.
std::string ActionName
The name of the action to run when using a plugin action.
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string FixItSuffix
If given, the new suffix for fix-it rewritten files.
enum clang::FrontendOptions::@201 ARCMTAction
static InputKind getInputKindForExtension(StringRef Extension)
getInputKindForExtension - Return the appropriate input kind for a file extension.
std::vector< std::string > Plugins
The list of plugins to load.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
unsigned DisableFree
Disable memory freeing on exit.
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
frontend::ActionKind ProgramAction
The frontend action to perform.
std::optional< std::vector< std::string > > AuxTargetFeatures
Auxiliary target features for CUDA/HIP compilation.
std::string AuxTriple
Auxiliary triple for CUDA/HIP compilation.
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
A diagnostic client that ignores all diagnostics.
@ None
No signing for any function.
@ NonLeaf
Sign the return address of functions that spill LR.
@ All
Sign the return address of all functions,.
@ BKey
Return address signing uses APIB key.
@ AKey
Return address signing uses APIA key.
@ None
Don't exclude any overflow patterns from sanitizers.
@ AddUnsignedOverflowTest
if (a + b < a)
@ All
Exclude all overflow patterns (below)
@ AddSignedOverflowTest
if (a + b < a)
@ PostDecrInWhile
while (count–)
@ Ver6
Attempt to be ABI-compatible with code generated by Clang 6.0.x (SVN r321711).
@ Ver18
Attempt to be ABI-compatible with code generated by Clang 18.0.x.
@ Ver4
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
@ Ver14
Attempt to be ABI-compatible with code generated by Clang 14.0.x.
@ Ver11
Attempt to be ABI-compatible with code generated by Clang 11.0.x (git 2e10b7a39b93).
@ Ver19
Attempt to be ABI-compatible with code generated by Clang 19.0.x.
@ Ver15
Attempt to be ABI-compatible with code generated by Clang 15.0.x.
@ Ver17
Attempt to be ABI-compatible with code generated by Clang 17.0.x.
@ Ver7
Attempt to be ABI-compatible with code generated by Clang 7.0.x (SVN r338536).
@ Latest
Conform to the underlying platform's C and C++ ABIs as closely as we can.
@ Ver3_8
Attempt to be ABI-compatible with code generated by Clang 3.8.x (SVN r257626).
@ Ver12
Attempt to be ABI-compatible with code generated by Clang 12.0.x (git 8e464dd76bef).
@ Ver9
Attempt to be ABI-compatible with code generated by Clang 9.0.x (SVN r351319).
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
void resetNonModularOptions()
Reset all of the options that are not considered when building a module.
std::optional< TargetCXXABI::Kind > CXXABI
C++ ABI to compile with, if specified by the frontend through -fc++-abi=.
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::string ModuleName
The module currently being compiled as specified by -fmodule-name.
clang::ObjCRuntime ObjCRuntime
std::string getOpenCLVersionString() const
Return the OpenCL C or C++ for OpenCL language name and version as a string.
unsigned OverflowPatternExclusionMask
Which overflow patterns should be excluded from sanitizer instrumentation.
SanitizerSet Sanitize
Set of enabled sanitizers.
bool UseTargetPathSeparator
Indicates whether to use target's platform-specific file separator when FILE macro is used and when c...
static void setLangDefaults(LangOptions &Opts, Language Lang, const llvm::Triple &T, std::vector< std::string > &Includes, LangStandard::Kind LangStd=LangStandard::lang_unspecified)
Set language defaults for the given input language and language standard in the given LangOptions obj...
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
std::string RandstructSeed
The seed used by the randomize structure layout feature.
std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap
A prefix map for FILE, BASE_FILE and __builtin_FILE().
LangStandard::Kind LangStd
The used language standard.
std::string OpenACCMacroOverride
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
bool SanitizeCoverage
Is at least one coverage instrumentation type enabled.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
std::vector< std::string > NoSanitizeFiles
Paths to files specifying which objects (files, functions, variables) should not be instrumented.
std::string CurrentModule
The name of the current module, of which the main source file is a part.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
The basic abstraction for the target Objective-C runtime.
bool allowsWeak() const
Does this runtime allow the use of __weak?
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
std::string getAsString() const
bool allowsARC() const
Does this runtime allow ARC at all?
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Discrimination
Forms of extra discrimination.
ARM8_3Key
Hardware pointer-signing keys in ARM8.3.
static constexpr std::optional< PositiveAnalyzerOption > create(unsigned Val)
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
bool PCHWithHdrStopCreate
When true, we are creating a PCH or creating the PCH object while expecting a #pragma hdrstop to sepa...
std::vector< std::string > Includes
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
bool LexEditorPlaceholders
When enabled, the preprocessor will construct editor placeholder tokens.
void resetNonModularOptions()
Reset any options that are not considered when building a module.
void addMacroUndef(StringRef Name)
std::set< std::string > DeserializedPCHDeclsToErrorOn
This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...
std::vector< std::string > EmbedEntries
User specified embed entries.
void addMacroDef(StringRef Name)
bool DefineTargetOSMacros
Indicates whether to predefine target OS macros.
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
bool PCHWithHdrStop
When true, we are creating or using a PCH where a #pragma hdrstop is expected to indicate the beginni...
std::optional< uint64_t > SourceDateEpoch
If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
void addRemappedFile(StringRef From, StringRef To)
std::vector< std::pair< std::string, bool > > Macros
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g....
unsigned ShowMacros
Print macro definitions.
unsigned ShowCPP
Print normal preprocessed output.
unsigned ShowLineMarkers
Show #line markers.
unsigned DirectivesOnly
Process directives but do not expand macros.
Encodes a location in the source.
static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind)
static const auto & getSpelling(Kind ABIKind)
static bool usesRelativeVTables(const llvm::Triple &T)
static bool isABI(StringRef Name)
Options for controlling the target.
std::string Triple
The name of the target triple to compile for.
llvm::VersionTuple SDKVersion
The version of the SDK which was used during the compilation.
uint64_t LargeDataThreshold
llvm::VersionTuple DarwinTargetVariantSDKVersion
The version of the darwin target variant SDK which was used during the compilation.
std::string HostTriple
When compiling for the device side, contains the triple used to compile for the host.
Action - Represent an abstract compilation step to perform.
static std::string GetResourcesPath(StringRef BinaryPath)
Takes the path to a binary that's either in bin/ or lib/ and returns the path to clang's resource dir...
constexpr XRayInstrMask None
constexpr XRayInstrMask All
const llvm::opt::OptTable & getDriverOptTable()
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
@ CXXSystem
Like System, but only used for C++.
@ Angled
Paths for '#include <>' added by '-I'.
@ CSystem
Like System, but only used for C.
@ System
Like Angled, but marks system directories.
@ Quoted
'#include ""' paths, added by 'gcc -iquote'.
@ ExternCSystem
Like System, but headers are implicitly wrapped in extern "C".
@ ObjCSystem
Like System, but only used for ObjC.
@ ObjCXXSystem
Like System, but only used for ObjC++.
@ After
Like System, but searched after the system directories.
@ GenerateHeaderUnit
Generate a C++20 header unit module from a header file.
@ VerifyPCH
Load and verify that a PCH file is usable.
@ PrintPreprocessedInput
-E mode.
@ RewriteTest
Rewriter playground.
@ ParseSyntaxOnly
Parse and perform semantic analysis.
@ TemplightDump
Dump template instantiations.
@ GenerateModuleInterface
Generate pre-compiled module from a standard C++ module interface unit.
@ EmitLLVM
Emit a .ll file.
@ PrintPreamble
Print the "preamble" of the input file.
@ MigrateSource
Run migrator.
@ InitOnly
Only execute frontend initialization.
@ ASTView
Parse ASTs and view them in Graphviz.
@ PluginAction
Run a plugin action,.
@ DumpRawTokens
Dump out raw tokens.
@ PrintDependencyDirectivesSourceMinimizerOutput
Print the output of the dependency directives source minimizer.
@ RewriteObjC
ObjC->C Rewriter.
@ RunPreprocessorOnly
Just lex, no output.
@ ModuleFileInfo
Dump information about a module file.
@ EmitCIR
Emit a .cir file.
@ DumpCompilerOptions
Dump the compiler configuration.
@ RunAnalysis
Run one or more source code analyses.
@ ASTPrint
Parse ASTs and print them.
@ GenerateReducedModuleInterface
Generate reduced module interface for a standard C++ module interface unit.
@ GenerateInterfaceStubs
Generate Interface Stub Files.
@ ASTDump
Parse ASTs and dump them.
@ DumpTokens
Dump out preprocessed tokens.
@ FixIt
Parse and apply any fixits to the source.
@ EmitAssembly
Emit a .s file.
@ EmitCodeGenOnly
Generate machine code, but don't emit anything.
@ RewriteMacros
Expand macros but not #includes.
@ EmitHTML
Translate input source into HTML.
@ GeneratePCH
Generate pre-compiled header.
@ EmitLLVMOnly
Generate LLVM IR, but do not emit anything.
@ GenerateModule
Generate pre-compiled module from a module map.
@ ASTDeclList
Parse ASTs and list Decl nodes.
const unsigned VERSION_MINOR
AST file minor version number supported by this version of Clang.
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
The JSON file list parser is used to communicate input to InstallAPI.
ASTDumpOutputFormat
Used to specify the format for printing AST dump information.
SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromOverlayFiles(ArrayRef< std::string > VFSOverlayFiles, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS)
DiagnosticLevelMask
A bitmask representing the diagnostic levels used by VerifyDiagnosticConsumer.
std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)
AnalysisConstraints
AnalysisConstraints - Set of available constraint models.
@ HIFIL_Only_Direct_System
void serializeSanitizerSet(SanitizerSet Set, SmallVectorImpl< StringRef > &Values)
Serialize a SanitizerSet into values for -fsanitize= or -fno-sanitize=.
LLVM_READONLY bool isLetter(unsigned char c)
Return true if this character is an ASCII letter: [a-zA-Z].
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
constexpr uint16_t InitFiniPointerConstantDiscriminator
Constant discriminator to be used with function pointers in .init_array and .fini_array.
@ C
Languages that the frontend can parse and compile.
@ CIR
LLVM IR & CIR: we accept these so that we can run the optimizer on them, and compile them to assembly...
@ Asm
Assembly: we accept this only so that we can preprocess it.
bool parseSanitizerWeightedValue(StringRef Value, bool AllowGroups, SanitizerMaskCutoffs &Cutoffs)
Parse a single weighted value (e.g., 'undefined=0.05') from a -fsanitize= or -fno-sanitize= value lis...
@ Result
The result type of a method or function.
XRayInstrMask parseXRayInstrValue(StringRef Value)
Parses a command line argument into a mask.
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
void serializeXRayInstrValue(XRayInstrSet Set, SmallVectorImpl< StringRef > &Values)
Serializes a set into a list of command line arguments.
AnalysisPurgeMode
AnalysisPurgeModes - Set of available strategies for dead symbol removal.
void serializeSanitizerMaskCutoffs(const SanitizerMaskCutoffs &Cutoffs, SmallVectorImpl< std::string > &Values)
Serialize a SanitizerMaskCutoffs into values for -fsanitize= or -fno-sanitize=.
ShaderStage
Shader programs run in specific pipeline stages.
constexpr uint16_t StdTypeInfoVTablePointerConstantDiscrimination
Constant discriminator for std::type_info vtable pointers: 0xB1EA/45546 The value is ptrauth_string_d...
SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups)
Parse a single value from a -fsanitize= or -fno-sanitize= value list.
const FunctionProtoType * T
AnalysisDiagClients
AnalysisDiagClients - Set of available diagnostic clients for rendering analysis results.
@ NUM_ANALYSIS_DIAG_CLIENTS
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
int getLastArgIntValue(const llvm::opt::ArgList &Args, llvm::opt::OptSpecifier Id, int Default, DiagnosticsEngine *Diags=nullptr, unsigned Base=0)
Return the value of the last argument as an integer, or a default.
bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args, DiagnosticsEngine *Diags=nullptr, bool DefaultDiagColor=true)
Fill out Opts based on the options given in Args.
@ Success
Template argument deduction was successful.
AnalysisInliningMode
AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
Diagnostic wrappers for TextAPI types for error reporting.
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
bool Internalize
If true, we use LLVM module internalizer.
bool PropagateAttrs
If true, we set attributes functions in the bitcode library according to our CodeGenOptions,...
std::string Filename
The filename of the bitcode file to link in.
unsigned LinkFlags
Bitwise combination of llvm::Linker::Flags, passed to the LLVM linker.
Dummy tag type whose instance can be passed into the constructor to prevent creation of the reference...
LangStandard - Information about the properties of a particular language standard.
static const LangStandard & getLangStandardForKind(Kind K)
const char * getName() const
getName - Get the name of this standard.
static Kind getLangKind(StringRef Name)
static ParsedSourceLocation FromString(StringRef Str)
Construct a parsed source location from a string; the Filename is empty on error.
std::string ToString() const
Serialize ParsedSourceLocation back to a string.
PointerAuthSchema CXXVTablePointers
The ABI for C++ virtual table pointers (the pointer to the table itself) as installed in an actual cl...
PointerAuthSchema InitFiniPointers
The ABI for function addresses in .init_array and .fini_array.
PointerAuthSchema CXXVTTVTablePointers
The ABI for C++ virtual table pointers as installed in a VTT.
bool ReturnAddresses
Should return addresses be authenticated?
PointerAuthSchema CXXTypeInfoVTablePointer
TypeInfo has external ABI requirements and is emitted without actually having parsed the libcxx defin...
bool AArch64JumpTableHardening
Use hardened lowering for jump-table dispatch?
PointerAuthSchema FunctionPointers
The ABI for C function pointers.
bool AuthTraps
Do authentication failures cause a trap?
PointerAuthSchema CXXMemberFunctionPointers
The ABI for C++ member function pointers.
PointerAuthSchema CXXVirtualVariadicFunctionPointers
The ABI for variadic C++ virtual function pointers.
PointerAuthSchema CXXVirtualFunctionPointers
The ABI for most C++ virtual function pointers, i.e. v-table entries.
bool IndirectGotos
Do indirect goto label addresses need to be authenticated?
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
bool empty() const
Returns true if no sanitizers are enabled.
SanitizerMask Mask
Bitmask of enabled sanitizers.