28#include "clang/Config/config.h"
44#include "llvm/ADT/APInt.h"
45#include "llvm/ADT/ArrayRef.h"
46#include "llvm/ADT/CachedHashString.h"
47#include "llvm/ADT/FloatingPointMode.h"
48#include "llvm/ADT/STLExtras.h"
49#include "llvm/ADT/SmallVector.h"
50#include "llvm/ADT/StringRef.h"
51#include "llvm/ADT/StringSwitch.h"
52#include "llvm/ADT/Twine.h"
53#include "llvm/Config/llvm-config.h"
54#include "llvm/Frontend/Debug/Options.h"
55#include "llvm/IR/DebugInfoMetadata.h"
56#include "llvm/Linker/Linker.h"
57#include "llvm/MC/MCTargetOptions.h"
58#include "llvm/Option/Arg.h"
59#include "llvm/Option/ArgList.h"
60#include "llvm/Option/OptSpecifier.h"
61#include "llvm/Option/OptTable.h"
62#include "llvm/Option/Option.h"
63#include "llvm/ProfileData/InstrProfReader.h"
64#include "llvm/Remarks/HotnessThresholdParser.h"
65#include "llvm/Support/CodeGen.h"
66#include "llvm/Support/Compiler.h"
67#include "llvm/Support/Error.h"
68#include "llvm/Support/ErrorHandling.h"
69#include "llvm/Support/ErrorOr.h"
70#include "llvm/Support/FileSystem.h"
71#include "llvm/Support/HashBuilder.h"
72#include "llvm/Support/MathExtras.h"
73#include "llvm/Support/MemoryBuffer.h"
74#include "llvm/Support/Path.h"
75#include "llvm/Support/Process.h"
76#include "llvm/Support/Regex.h"
77#include "llvm/Support/VersionTuple.h"
78#include "llvm/Support/VirtualFileSystem.h"
79#include "llvm/Support/raw_ostream.h"
80#include "llvm/Target/TargetOptions.h"
81#include "llvm/TargetParser/Host.h"
82#include "llvm/TargetParser/Triple.h"
111 if (Arg.getAsInteger(10, Val))
112 return llvm::createStringError(llvm::inconvertibleErrorCode(),
113 "Not an integer: %s", Arg.data());
122 return std::make_shared<T>(
X);
193 if (Storage.use_count() > 1)
194 Storage = std::make_shared<T>(*Storage);
257#define OPTTABLE_STR_TABLE_CODE
258#include "clang/Driver/Options.inc"
259#undef OPTTABLE_STR_TABLE_CODE
262 return OptionStrTable[Offset];
265#define SIMPLE_ENUM_VALUE_TABLE
266#include "clang/Driver/Options.inc"
267#undef SIMPLE_ENUM_VALUE_TABLE
273 if (Args.hasArg(Opt))
282 if (Args.hasArg(Opt))
292 unsigned SpellingOffset, Option::OptionClass,
297 const Twine &Spelling, Option::OptionClass,
303 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
307 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
309 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
311 if (Args.hasArg(Opt))
318 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
324 OptSpecifier OtherOpt) {
325 return [
Value, OtherValue,
326 OtherOpt](OptSpecifier Opt,
unsigned,
const ArgList &Args,
328 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
329 return A->getOption().matches(Opt) ?
Value : OtherValue;
337 Option::OptionClass,
unsigned,
bool KeyPath) {
338 if (KeyPath ==
Value)
344 const Twine &Spelling,
345 Option::OptionClass OptClass,
unsigned,
346 const Twine &
Value) {
348 case Option::SeparateClass:
349 case Option::JoinedOrSeparateClass:
350 case Option::JoinedAndSeparateClass:
354 case Option::JoinedClass:
355 case Option::CommaJoinedClass:
356 Consumer(Spelling +
Value);
359 llvm_unreachable(
"Cannot denormalize an option with option class "
360 "incompatible with string denormalization.");
367 Option::OptionClass OptClass,
unsigned TableIndex,
T Value) {
369 TableIndex, Twine(
Value));
374 Option::OptionClass OptClass,
unsigned TableIndex,
379static std::optional<SimpleEnumValue>
381 for (
int I = 0, E = Table.Size; I != E; ++I)
382 if (Name == Table.Table[I].Name)
383 return Table.Table[I];
388static std::optional<SimpleEnumValue>
390 for (
int I = 0, E = Table.Size; I != E; ++I)
392 return Table.Table[I];
401 assert(TableIndex < SimpleEnumValueTablesSize);
402 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
404 auto *Arg = Args.getLastArg(Opt);
408 StringRef ArgValue = Arg->getValue();
410 return MaybeEnumVal->Value;
412 Diags.
Report(diag::err_drv_invalid_value)
413 << Arg->getAsString(Args) << ArgValue;
418 unsigned SpellingOffset,
419 Option::OptionClass OptClass,
420 unsigned TableIndex,
unsigned Value) {
421 assert(TableIndex < SimpleEnumValueTablesSize);
422 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
425 TableIndex, MaybeEnumVal->Name);
427 llvm_unreachable(
"The simple enum value was not correctly defined in "
428 "the tablegen option description");
434 unsigned SpellingOffset,
435 Option::OptionClass OptClass,
436 unsigned TableIndex,
T Value) {
438 TableIndex,
static_cast<unsigned>(
Value));
445 auto *Arg = Args.getLastArg(Opt);
448 return std::string(Arg->getValue());
451template <
typename IntTy>
455 auto *Arg = Args.getLastArg(Opt);
459 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
460 Diags.
Report(diag::err_drv_invalid_int_value)
461 << Arg->getAsString(Args) << Arg->getValue();
467static std::optional<std::vector<std::string>>
470 return Args.getAllArgValues(Opt);
474 unsigned SpellingOffset,
475 Option::OptionClass OptClass,
477 const std::vector<std::string> &Values) {
479 case Option::CommaJoinedClass: {
480 std::string CommaJoinedValue;
481 if (!Values.empty()) {
482 CommaJoinedValue.append(Values.front());
483 for (
const std::string &
Value : llvm::drop_begin(Values, 1)) {
484 CommaJoinedValue.append(
",");
485 CommaJoinedValue.append(
Value);
489 Option::OptionClass::JoinedClass, TableIndex,
493 case Option::JoinedClass:
494 case Option::SeparateClass:
495 case Option::JoinedOrSeparateClass:
496 for (
const std::string &
Value : Values)
500 llvm_unreachable(
"Cannot denormalize an option with option class "
501 "incompatible with string vector denormalization.");
509 auto *Arg = Args.getLastArg(Opt);
512 return llvm::Triple::normalize(Arg->getValue());
515template <
typename T,
typename U>
517 return static_cast<T>(
Value);
521 return KeyPath |
Value;
528template <
typename T,
typename U, U Value>
533#define PARSE_OPTION_WITH_MARSHALLING( \
534 ARGS, DIAGS, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, \
535 ALIASARGS, FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, \
536 METAVAR, VALUES, SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
537 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \
538 MERGER, EXTRACTOR, TABLE_INDEX) \
539 if ((VISIBILITY) & options::CC1Option) { \
540 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
542 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
544 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
546 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
551#define GENERATE_OPTION_WITH_MARSHALLING( \
552 CONSUMER, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, ALIASARGS, \
553 FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
554 SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
555 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
557 if ((VISIBILITY) & options::CC1Option) { \
558 [&](const auto &Extracted) { \
561 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
562 : (DEFAULT_VALUE)))) \
563 DENORMALIZER(CONSUMER, SPELLING_OFFSET, Option::KIND##Class, \
564 TABLE_INDEX, Extracted); \
565 }(EXTRACTOR(KEYPATH)); \
579 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
580 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
581 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
582 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
585 CodeGenOpts.ClearASTBeforeBackend =
false;
587 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
588 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
591 llvm::Triple
T(TargetOpts.
Triple);
592 llvm::Triple::ArchType
Arch =
T.getArch();
597 if (CodeGenOpts.getExceptionHandling() !=
599 T.isWindowsMSVCEnvironment())
600 Diags.
Report(diag::err_fe_invalid_exception_model)
601 <<
static_cast<unsigned>(CodeGenOpts.getExceptionHandling()) <<
T.str();
603 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
604 Diags.
Report(diag::warn_c_kext);
606 if (LangOpts.NewAlignOverride &&
607 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
608 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
609 Diags.
Report(diag::err_fe_invalid_alignment)
610 << A->getAsString(Args) << A->getValue();
611 LangOpts.NewAlignOverride = 0;
616 if (LangOpts.CPlusPlus11) {
617 if (Args.hasArg(OPT_fraw_string_literals, OPT_fno_raw_string_literals)) {
618 Args.claimAllArgs(OPT_fraw_string_literals, OPT_fno_raw_string_literals);
619 Diags.
Report(diag::warn_drv_fraw_string_literals_in_cxx11)
620 <<
bool(LangOpts.RawStringLiterals);
624 LangOpts.RawStringLiterals =
true;
627 LangOpts.NamedLoops =
628 Args.hasFlag(OPT_fnamed_loops, OPT_fno_named_loops, LangOpts.C2y);
631 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
632 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
635 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
636 Diags.
Report(diag::err_drv_argument_not_allowed_with)
639 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
640 Diags.
Report(diag::err_drv_argument_not_allowed_with)
643 if (Args.hasArg(OPT_fdx_rootsignature_version) && !LangOpts.HLSL)
644 Diags.
Report(diag::err_drv_argument_not_allowed_with)
647 if (Args.hasArg(OPT_fdx_rootsignature_define) && !LangOpts.HLSL)
648 Diags.
Report(diag::err_drv_argument_not_allowed_with)
651 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
652 Diags.
Report(diag::warn_ignored_hip_only_option)
653 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
655 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
656 Diags.
Report(diag::warn_ignored_hip_only_option)
657 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
666 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
667 if (LangOpts.ApproxFunc)
668 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
669 if (LangOpts.AllowFPReassoc)
670 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
671 if (LangOpts.AllowRecip)
672 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
678 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
680 Diags.
Report(diag::warn_option_invalid_ocl_version)
682 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
684 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
685 auto DefaultCC = LangOpts.getDefaultCallingConv();
689 Arch != llvm::Triple::x86;
695 Diags.
Report(diag::err_drv_argument_not_allowed_with)
696 << A->getSpelling() <<
T.getTriple();
708 unsigned DefaultOpt = 0;
711 !Args.hasArg(OPT_cl_opt_disable))
714 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
715 if (A->getOption().matches(options::OPT_O0))
718 if (A->getOption().matches(options::OPT_Ofast))
721 assert(A->getOption().matches(options::OPT_O));
723 StringRef S(A->getValue());
724 if (S ==
"s" || S ==
"z")
737 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
738 if (A->getOption().matches(options::OPT_O)) {
739 switch (A->getValue()[0]) {
753 llvm::opt::OptSpecifier OptSpecifier) {
756 Option::OptionClass::FlagClass, 0);
760 llvm::opt::OptSpecifier OptSpecifier,
761 const Twine &
Value) {
799 bool CheckAgainstOriginalInvocation =
false,
800 bool ForceRoundTrip =
false) {
802 bool DoRoundTripDefault =
true;
804 bool DoRoundTripDefault =
false;
807 bool DoRoundTrip = DoRoundTripDefault;
808 if (ForceRoundTrip) {
811 for (
const auto *Arg : CommandLineArgs) {
812 if (Arg == StringRef(
"-round-trip-args"))
814 if (Arg == StringRef(
"-no-round-trip-args"))
822 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
827 llvm::raw_string_ostream OS(Buffer);
828 for (
const char *Arg : Args) {
829 llvm::sys::printArg(OS, Arg,
true);
842 if (!
Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
849 auto Success =
Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
855 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
856 Diags.
Report(diag::note_cc1_round_trip_original)
857 << SerializeArgs(CommandLineArgs);
862 llvm::BumpPtrAllocator Alloc;
863 llvm::StringSaver StringPool(Alloc);
864 auto SA = [&StringPool](
const Twine &Arg) {
865 return StringPool.save(Arg).data();
872 Generate(DummyInvocation, GeneratedArgs, SA);
878 bool Success2 =
Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
883 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
884 Diags.
Report(diag::note_cc1_round_trip_generated)
885 << 1 << SerializeArgs(GeneratedArgs);
890 if (CheckAgainstOriginalInvocation)
892 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
896 Generate(RealInvocation, ComparisonArgs, SA);
901 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
902 [](
const char *AElem,
const char *BElem) {
903 return StringRef(AElem) == StringRef(BElem);
910 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
911 Diags.
Report(diag::err_cc1_round_trip_mismatch);
912 Diags.
Report(diag::note_cc1_round_trip_generated)
913 << 1 << SerializeArgs(GeneratedArgs);
914 Diags.
Report(diag::note_cc1_round_trip_generated)
915 << 2 << SerializeArgs(ComparisonArgs);
919 Diags.
Report(diag::remark_cc1_round_trip_generated)
920 << 1 << SerializeArgs(GeneratedArgs);
921 Diags.
Report(diag::remark_cc1_round_trip_generated)
922 << 2 << SerializeArgs(ComparisonArgs);
934 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
938 Args.push_back(
"-cc1");
941 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
946 OptSpecifier GroupWithValue,
947 std::vector<std::string> &Diagnostics) {
948 for (
auto *A : Args.filtered(Group)) {
949 if (A->getOption().getKind() == Option::FlagClass) {
952 Diagnostics.push_back(
953 std::string(A->getOption().getName().drop_front(1)));
954 }
else if (A->getOption().matches(GroupWithValue)) {
957 Diagnostics.push_back(
958 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
961 Diagnostics.push_back(A->getValue());
972 std::vector<std::string> &Funcs) {
973 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
975 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
982#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
983 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
984#include "clang/Driver/Options.inc"
985#undef ANALYZER_OPTION_WITH_MARSHALLING
989#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
991 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \
993#include "clang/StaticAnalyzer/Core/Analyses.def"
995 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
1001#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1003 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \
1005#include "clang/StaticAnalyzer/Core/Analyses.def"
1007 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
1013#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1015 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \
1017#include "clang/StaticAnalyzer/Core/Analyses.def"
1019 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
1025#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1027 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \
1029#include "clang/StaticAnalyzer/Core/Analyses.def"
1031 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
1037 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
1046 for (
const auto &
C : Opts.
Config)
1047 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
1048 llvm::sort(SortedConfigOpts, llvm::less_first());
1050 for (
const auto &[Key,
Value] : SortedConfigOpts) {
1053 auto Entry = ConfigOpts.
Config.find(Key);
1054 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
1069#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
1070 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1071#include "clang/Driver/Options.inc"
1072#undef ANALYZER_OPTION_WITH_MARSHALLING
1074 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
1075 StringRef Name = A->getValue();
1077#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1078 .Case(CMDFLAG, NAME##Model)
1079#include "clang/StaticAnalyzer/Core/Analyses.def"
1082 Diags.
Report(diag::err_drv_invalid_value)
1083 << A->getAsString(Args) << Name;
1086 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
1087 Diags.
Report(diag::err_analyzer_not_built_with_z3);
1094 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
1095 StringRef Name = A->getValue();
1097#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1098 .Case(CMDFLAG, PD_##NAME)
1099#include "clang/StaticAnalyzer/Core/Analyses.def"
1102 Diags.
Report(diag::err_drv_invalid_value)
1103 << A->getAsString(Args) << Name;
1109 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
1110 StringRef Name = A->getValue();
1112#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1113 .Case(CMDFLAG, NAME)
1114#include "clang/StaticAnalyzer/Core/Analyses.def"
1117 Diags.
Report(diag::err_drv_invalid_value)
1118 << A->getAsString(Args) << Name;
1124 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
1125 StringRef Name = A->getValue();
1127#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1128 .Case(CMDFLAG, NAME)
1129#include "clang/StaticAnalyzer/Core/Analyses.def"
1132 Diags.
Report(diag::err_drv_invalid_value)
1133 << A->getAsString(Args) << Name;
1141 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1143 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1146 StringRef CheckerAndPackageList = A->getValue();
1148 CheckerAndPackageList.split(CheckersAndPackages,
",");
1149 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1155 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1159 StringRef configList = A->getValue();
1161 configList.split(configVals,
",");
1162 for (
const auto &configVal : configVals) {
1164 std::tie(key, val) = configVal.split(
"=");
1167 diag::err_analyzer_config_no_value) << configVal;
1170 if (val.contains(
'=')) {
1172 diag::err_analyzer_config_multiple_values)
1181 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1186 Opts.
Config[key] = std::string(val);
1196 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1199 os << Args.getArgString(i);
1206 StringRef OptionName, StringRef DefaultVal) {
1207 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1212 StringRef &OptionField, StringRef Name,
1213 StringRef DefaultVal) {
1222 bool &OptionField, StringRef Name,
bool DefaultVal) {
1223 auto PossiblyInvalidVal =
1224 llvm::StringSwitch<std::optional<bool>>(
1227 .Case(
"false",
false)
1228 .Default(std::nullopt);
1230 if (!PossiblyInvalidVal) {
1232 Diags->
Report(diag::err_analyzer_config_invalid_input)
1233 << Name <<
"a boolean";
1235 OptionField = DefaultVal;
1237 OptionField = *PossiblyInvalidVal;
1242 unsigned &OptionField, StringRef Name,
1243 unsigned DefaultVal) {
1245 OptionField = DefaultVal;
1246 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1247 .getAsInteger(0, OptionField);
1248 if (Diags && HasFailed)
1249 Diags->
Report(diag::err_analyzer_config_invalid_input)
1250 << Name <<
"an unsigned";
1256 unsigned DefaultVal) {
1259 if (Parsed.has_value()) {
1260 OptionField = Parsed.value();
1263 if (Diags && !Parsed.has_value())
1264 Diags->
Report(diag::err_analyzer_config_invalid_input)
1265 << Name <<
"a positive";
1267 OptionField = DefaultVal;
1275#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1276 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1277#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1278#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1280 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1281 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1283#define ANALYZER_OPTION(...)
1284#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1285 SHALLOW_VAL, DEEP_VAL) \
1286 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1287 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1288#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1295 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1296 std::vector<StringRef> Checkers =
1298 std::vector<StringRef> Packages =
1302 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1304 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1306 bool IsChecker = CheckerOrPackage.contains(
'.');
1307 bool IsValidName = IsChecker
1308 ? llvm::is_contained(Checkers, CheckerOrPackage)
1309 : llvm::is_contained(Packages, CheckerOrPackage);
1312 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1313 << CheckerOrPackage;
1323 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1324 Diags->
Report(diag::err_analyzer_config_invalid_input)
1325 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1333 if (
Remark.hasValidPattern()) {
1338 GenerateArg(Consumer, OPT_R_Joined, StringRef(
"no-") + Name);
1347 OptSpecifier OptEQ, StringRef Name) {
1350 auto InitializeResultPattern = [&Diags, &Args, &Result](
const Arg *A,
1351 StringRef Pattern) {
1352 Result.Pattern = Pattern.str();
1354 std::string RegexError;
1355 Result.Regex = std::make_shared<llvm::Regex>(Result.Pattern);
1356 if (!Result.Regex->isValid(RegexError)) {
1357 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1358 << RegexError << A->getAsString(Args);
1365 for (Arg *A : Args) {
1366 if (A->getOption().matches(OPT_R_Joined)) {
1367 StringRef
Value = A->getValue();
1371 else if (
Value ==
"everything")
1373 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1375 else if (
Value ==
"no-everything")
1382 Result.Pattern =
"";
1383 Result.Regex =
nullptr;
1385 InitializeResultPattern(A,
".*");
1387 }
else if (A->getOption().matches(OptEQ)) {
1389 if (!InitializeResultPattern(A, A->getValue()))
1398 const std::vector<std::string> &Levels,
1402 for (
const auto &Level : Levels) {
1404 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1412 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1420 const std::vector<std::string> &Sanitizers,
1422 for (
const auto &Sanitizer : Sanitizers) {
1425 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1439 const std::vector<std::string> &Sanitizers,
1442 for (
const auto &Sanitizer : Sanitizers) {
1444 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1453 llvm::SplitString(Bundle, BundleParts,
",");
1454 for (
const auto &B : BundleParts) {
1458 D.
Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1472 llvm::raw_string_ostream OS(Buffer);
1473 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1479 const llvm::Triple &Triple) {
1480 assert(Triple.getArch() == llvm::Triple::aarch64);
1487 LangOpts.PointerAuthFunctionTypeDiscrimination ? Discrimination::Type
1488 : Discrimination::None);
1491 Key::ASDA,
LangOpts.PointerAuthVTPtrAddressDiscrimination,
1492 LangOpts.PointerAuthVTPtrTypeDiscrimination ? Discrimination::Type
1493 : Discrimination::None);
1495 if (
LangOpts.PointerAuthTypeInfoVTPtrDiscrimination)
1510 if (
LangOpts.PointerAuthInitFini) {
1512 Key::ASIA,
LangOpts.PointerAuthInitFiniAddressDiscrimination,
1522 if (
LangOpts.PointerAuthBlockDescriptorPointers)
1541 if (
LangOpts.PointerAuthObjcClassROPointers)
1554 const llvm::Triple &Triple,
1556 if (!LangOpts.PointerAuthCalls && !LangOpts.PointerAuthReturns &&
1557 !LangOpts.PointerAuthAuthTraps && !LangOpts.PointerAuthIndirectGotos &&
1558 !LangOpts.AArch64JumpTableHardening)
1564void CompilerInvocationBase::GenerateCodeGenArgs(
const CodeGenOptions &Opts,
1566 const llvm::Triple &
T,
1567 const std::string &OutputFile,
1571 if (Opts.OptimizationLevel == 0)
1574 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));
1576#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1577 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
1578#include "clang/Driver/Options.inc"
1579#undef CODEGEN_OPTION_WITH_MARSHALLING
1581 if (Opts.OptimizationLevel > 0) {
1585 GenerateArg(Consumer, OPT_finline_hint_functions);
1590 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1591 GenerateArg(Consumer, OPT_fdirect_access_external_data);
1592 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1593 GenerateArg(Consumer, OPT_fno_direct_access_external_data);
1595 std::optional<StringRef> DebugInfoVal;
1596 switch (Opts.DebugInfo) {
1597 case llvm::codegenoptions::DebugLineTablesOnly:
1598 DebugInfoVal =
"line-tables-only";
1600 case llvm::codegenoptions::DebugDirectivesOnly:
1601 DebugInfoVal =
"line-directives-only";
1603 case llvm::codegenoptions::DebugInfoConstructor:
1604 DebugInfoVal =
"constructor";
1606 case llvm::codegenoptions::LimitedDebugInfo:
1607 DebugInfoVal =
"limited";
1609 case llvm::codegenoptions::FullDebugInfo:
1610 DebugInfoVal =
"standalone";
1612 case llvm::codegenoptions::UnusedTypeInfo:
1613 DebugInfoVal =
"unused-types";
1615 case llvm::codegenoptions::NoDebugInfo:
1616 DebugInfoVal = std::nullopt;
1618 case llvm::codegenoptions::LocTrackingOnly:
1619 DebugInfoVal = std::nullopt;
1623 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
1627 Prefix.first +
"=" + Prefix.second);
1630 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
1631 Prefix.first +
"=" + Prefix.second);
1633 if (Opts.NewStructPathTBAA)
1636 if (Opts.OptimizeSize == 1)
1638 else if (Opts.OptimizeSize == 2)
1646 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1648 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1651 if (Opts.InterchangeLoops)
1657 GenerateArg(Consumer, OPT_fexperimental_loop_fusion);
1662 if (Opts.DebugNameTable ==
1663 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1665 else if (Opts.DebugNameTable ==
1666 static_cast<unsigned>(
1667 llvm::DICompileUnit::DebugNameTableKind::Default))
1670 if (Opts.DebugTemplateAlias)
1673 auto TNK = Opts.getDebugSimpleTemplateNames();
1674 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1675 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1676 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"simple");
1677 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1678 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"mangled");
1683 if (Opts.TimePasses) {
1684 if (Opts.TimePassesPerRun)
1685 GenerateArg(Consumer, OPT_ftime_report_EQ,
"per-pass-run");
1689 if (Opts.TimePassesJson)
1693 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1696 if (Opts.PrepareForThinLTO)
1705 StringRef MemProfileBasename(
"memprof.profraw");
1726 std::string InstrBundle =
1728 if (!InstrBundle.empty())
1729 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);
1732 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1733 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"full");
1734 else if (Opts.CFProtectionReturn)
1735 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"return");
1736 else if (Opts.CFProtectionBranch)
1737 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"branch");
1739 if (Opts.CFProtectionBranch) {
1740 switch (Opts.getCFBranchLabelScheme()) {
1743#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \
1744 case CFBranchLabelSchemeKind::Kind: \
1745 GenerateArg(Consumer, OPT_mcf_branch_label_scheme_EQ, #FlagVal); \
1747#include "clang/Basic/CFProtectionOptions.def"
1751 if (Opts.FunctionReturnThunks)
1752 GenerateArg(Consumer, OPT_mfunction_return_EQ,
"thunk-extern");
1755 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1756 F.PropagateAttrs && F.Internalize;
1758 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1762 if (Opts.EmulatedTLS)
1770 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,
1775 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1779 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1783 if (Opts.EnableAIXExtendedAltivecABI)
1786 if (Opts.XCOFFReadOnlyPointers)
1804 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,
1809 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,
1813 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);
1816 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);
1818 for (StringRef Sanitizer :
1820 GenerateArg(Consumer, OPT_fsanitize_merge_handlers_EQ, Sanitizer);
1822 SmallVector<std::string, 4> Values;
1824 for (std::string Sanitizer : Values)
1825 GenerateArg(Consumer, OPT_fsanitize_skip_hot_cutoff_EQ, Sanitizer);
1828 GenerateArg(Consumer, OPT_fallow_runtime_check_skip_hot_cutoff_EQ,
1832 for (StringRef Sanitizer :
1834 GenerateArg(Consumer, OPT_fsanitize_annotate_debug_info_EQ, Sanitizer);
1840 if (!Opts.EmitVersionIdentMetadata)
1843 switch (Opts.FiniteLoops) {
1854 if (Opts.StaticClosure)
1858bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1861 const llvm::Triple &
T,
1862 const std::string &OutputFile,
1868 unsigned MaxOptLevel = 3;
1869 if (OptimizationLevel > MaxOptLevel) {
1872 Diags.
Report(diag::warn_drv_optimization_value)
1873 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1874 OptimizationLevel = MaxOptLevel;
1876 Opts.OptimizationLevel = OptimizationLevel;
1883 const LangOptions *
LangOpts = &LangOptsRef;
1885#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1886 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1887#include "clang/Driver/Options.inc"
1888#undef CODEGEN_OPTION_WITH_MARSHALLING
1892 if (Opts.OptimizationLevel == 0) {
1894 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1895 options::OPT_finline_hint_functions,
1896 options::OPT_fno_inline_functions,
1897 options::OPT_fno_inline)) {
1900 if (A->getOption().matches(options::OPT_finline_functions))
1902 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1912 Opts.DirectAccessExternalData =
1913 Args.hasArg(OPT_fdirect_access_external_data) ||
1914 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1917 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1919 llvm::StringSwitch<unsigned>(A->getValue())
1920 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1921 .Case(
"line-directives-only",
1922 llvm::codegenoptions::DebugDirectivesOnly)
1923 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1924 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1925 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1926 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1929 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1932 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1938 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1939 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1940 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1941 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1942 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1943 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1944 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1947 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1948 auto Split = StringRef(Arg).split(
'=');
1952 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1953 auto Split = StringRef(Arg).split(
'=');
1957 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1958 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1959 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1960 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el,
1961 llvm::Triple::riscv32, llvm::Triple::riscv64};
1964 llvm::is_contained(DebugEntryValueArchs,
T.getArch()))
1965 Opts.EmitCallSiteInfo =
true;
1968 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1973 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1974 Args.hasArg(OPT_new_struct_path_tbaa);
1976 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1977 if (Opts.SimplifyLibCalls)
1980 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1981 (Opts.OptimizationLevel > 1));
1982 Opts.InterchangeLoops =
1983 Args.hasFlag(OPT_floop_interchange, OPT_fno_loop_interchange,
false);
1984 Opts.FuseLoops = Args.hasFlag(OPT_fexperimental_loop_fusion,
1985 OPT_fno_experimental_loop_fusion,
false);
1987 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1989 Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);
1991 Opts.DebugNameTable =
static_cast<unsigned>(
1992 Args.hasArg(OPT_ggnu_pubnames)
1993 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1994 : Args.hasArg(OPT_gpubnames)
1995 ? llvm::DICompileUnit::DebugNameTableKind::Default
1996 : llvm::DICompileUnit::DebugNameTableKind::None);
1997 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1998 StringRef
Value = A->getValue();
2000 Diags.
Report(diag::err_drv_unsupported_option_argument)
2001 << A->getSpelling() << A->getValue();
2002 Opts.setDebugSimpleTemplateNames(
2003 StringRef(A->getValue()) ==
"simple"
2004 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
2005 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
2008 if (Args.hasArg(OPT_ftime_report, OPT_ftime_report_EQ, OPT_ftime_report_json,
2009 OPT_stats_file_timers)) {
2010 Opts.TimePasses =
true;
2013 if (
const Arg *EQ = Args.getLastArg(OPT_ftime_report_EQ)) {
2014 StringRef Val =
EQ->getValue();
2015 if (Val ==
"per-pass")
2016 Opts.TimePassesPerRun =
false;
2017 else if (Val ==
"per-pass-run")
2018 Opts.TimePassesPerRun =
true;
2020 Diags.
Report(diag::err_drv_invalid_value)
2021 <<
EQ->getAsString(Args) <<
EQ->getValue();
2024 if (Args.getLastArg(OPT_ftime_report_json))
2025 Opts.TimePassesJson =
true;
2028 Opts.PrepareForLTO =
false;
2029 Opts.PrepareForThinLTO =
false;
2030 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
2031 Opts.PrepareForLTO =
true;
2032 StringRef S = A->getValue();
2034 Opts.PrepareForThinLTO =
true;
2035 else if (S !=
"full")
2036 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
2037 if (Args.hasArg(OPT_funified_lto))
2038 Opts.PrepareForThinLTO =
true;
2040 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
2042 Diags.
Report(diag::err_drv_argument_only_allowed_with)
2043 << A->getAsString(Args) <<
"-x ir";
2045 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
2047 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
2049 llvm::StringSwitch<std::string>(A->getValue())
2050 .Case(
"obj", OutputFile)
2051 .Default(llvm::sys::path::filename(OutputFile).str());
2054 const char *MemProfileBasename =
"memprof.profraw";
2055 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
2056 SmallString<128> Path(Args.getLastArgValue(OPT_fmemory_profile_EQ));
2057 llvm::sys::path::append(Path, MemProfileBasename);
2059 }
else if (Args.hasArg(OPT_fmemory_profile))
2063 if (Args.hasArg(OPT_coverage_version_EQ)) {
2064 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
2065 if (CoverageVersion.size() != 4) {
2066 Diags.
Report(diag::err_drv_invalid_value)
2067 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
2077 for (
const auto &A : Args) {
2079 if (A->getOption().getID() == options::OPT_o ||
2080 A->getOption().getID() == options::OPT_INPUT ||
2081 A->getOption().getID() == options::OPT_x ||
2082 A->getOption().getID() == options::OPT_fembed_bitcode ||
2083 A->getOption().matches(options::OPT_W_Group))
2086 A->render(Args, ASL);
2087 for (
const auto &arg : ASL) {
2088 StringRef ArgStr(arg);
2089 llvm::append_range(Opts.
CmdArgs, ArgStr);
2095 auto XRayInstrBundles =
2096 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
2097 if (XRayInstrBundles.empty())
2100 for (
const auto &A : XRayInstrBundles)
2104 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
2105 StringRef Name = A->getValue();
2106 if (Name ==
"full") {
2107 Opts.CFProtectionReturn = 1;
2108 Opts.CFProtectionBranch = 1;
2109 }
else if (Name ==
"return")
2110 Opts.CFProtectionReturn = 1;
2111 else if (Name ==
"branch")
2112 Opts.CFProtectionBranch = 1;
2113 else if (Name !=
"none")
2114 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
2117 if (Opts.CFProtectionBranch &&
T.isRISCV()) {
2118 if (
const Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {
2120 llvm::StringSwitch<CFBranchLabelSchemeKind>(A->getValue())
2121#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \
2122 .Case(#FlagVal, CFBranchLabelSchemeKind::Kind)
2123#include "clang/Basic/CFProtectionOptions.def"
2126 Opts.setCFBranchLabelScheme(Scheme);
2128 Diags.
Report(diag::err_drv_invalid_value)
2129 << A->getAsString(Args) << A->getValue();
2133 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
2134 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
2135 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
2136 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
2137 .Default(llvm::FunctionReturnThunksKind::Invalid);
2140 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2141 << A->getSpelling() <<
T.getTriple();
2142 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
2143 Diags.
Report(diag::err_drv_invalid_value)
2144 << A->getAsString(Args) << A->getValue();
2145 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
2146 Args.getLastArgValue(OPT_mcmodel_EQ) ==
"large")
2147 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2148 << A->getAsString(Args)
2149 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
2151 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
2155 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
2156 CodeGenOptions::BitcodeFileToLink F;
2158 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
2159 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
2168 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
2169 StringRef Val = A->getValue();
2173 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2176 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
2177 StringRef Val = A->getValue();
2180 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2186 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
2187 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
2191 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2192 << A->getSpelling() <<
T.str();
2194 const Option &O = A->getOption();
2195 if (O.matches(OPT_fpcc_struct_return) ||
2196 O.matches(OPT_maix_struct_return)) {
2199 assert(O.matches(OPT_freg_struct_return) ||
2200 O.matches(OPT_msvr4_struct_return));
2205 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {
2207 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2208 << A->getSpelling() <<
T.str();
2218 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,
false))
2219 Diags.
Report(diag::err_roptr_requires_data_sections);
2221 Opts.XCOFFReadOnlyPointers =
true;
2224 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
2225 if (!
T.isOSAIX() ||
T.isPPC32())
2226 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2227 << A->getSpelling() <<
T.str();
2230 bool NeedLocTracking =
false;
2233 NeedLocTracking =
true;
2235 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
2237 NeedLocTracking =
true;
2240 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
2242 NeedLocTracking =
true;
2252 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
2262 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
2265 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2266 <<
"-fdiagnostics-show-hotness";
2270 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2272 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2275 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2276 <<
"-fdiagnostics-hotness-threshold=";
2282 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2283 <<
"-fdiagnostics-hotness-threshold=";
2288 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2292 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2293 <<
"-fdiagnostics-misexpect-tolerance=";
2299 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2300 <<
"-fdiagnostics-misexpect-tolerance=";
2307 if (UsingSampleProfile)
2308 NeedLocTracking =
true;
2311 NeedLocTracking =
true;
2315 if (NeedLocTracking &&
2316 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2317 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2322 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2325 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2328 Args.getAllArgValues(OPT_fsanitize_merge_handlers_EQ),
2333 "-fsanitize-skip-hot-cutoff=",
2334 Args.getAllArgValues(OPT_fsanitize_skip_hot_cutoff_EQ), Diags);
2337 "-fsanitize-annotate-debug-info=",
2338 Args.getAllArgValues(OPT_fsanitize_annotate_debug_info_EQ), Diags,
2342 Args.getLastArgValue(OPT_fallow_runtime_check_skip_hot_cutoff_EQ);
2345 if (
V.getAsDouble(A) || A < 0.0 || A > 1.0) {
2346 Diags.
Report(diag::err_drv_invalid_value)
2347 <<
"-fallow-runtime-check-skip-hot-cutoff=" <<
V;
2353 if (
const auto *Arg = Args.getLastArg(options::OPT_falloc_token_max_EQ)) {
2354 StringRef S = Arg->getValue();
2356 if (S.getAsInteger(0,
Value))
2357 Diags.
Report(diag::err_drv_invalid_value) << Arg->getAsString(Args) << S;
2362 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2367 if (Args.hasArg(options::OPT_ffinite_loops))
2369 else if (Args.hasArg(options::OPT_fno_finite_loops))
2372 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2373 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2374 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2375 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2377 Opts.StaticClosure = Args.hasArg(options::OPT_static_libclosure);
2385#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2386 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2387#include "clang/Driver/Options.inc"
2388#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2393 for (
const auto &Dep : Opts.
ExtraDeps) {
2394 switch (Dep.second) {
2407 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);
2416 bool ShowLineMarkers) {
2420#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2421 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2422#include "clang/Driver/Options.inc"
2423#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2425 if (Args.hasArg(OPT_show_includes)) {
2440 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2441 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2442 StringRef Val = A->getValue();
2443 if (!Val.contains(
'='))
2447 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2448 StringRef Val = A->getValue();
2449 if (!Val.contains(
'='))
2456 for (
const auto &Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2460 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2464 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2465 StringRef Val = A->getValue();
2466 if (!Val.contains(
'='))
2474 if (Args.hasArg(OPT_header_include_format_EQ))
2475 Diags.
Report(diag::err_drv_print_header_cc1_invalid_combination)
2479 Diags.
Report(diag::err_drv_print_header_cc1_invalid_filtering)
2483 if (Args.hasArg(OPT_header_include_filtering_EQ))
2484 Diags.
Report(diag::err_drv_print_header_cc1_invalid_combination)
2488 Diags.
Report(diag::err_drv_print_header_cc1_invalid_format)
2504 } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2505 for (
auto *A : Args) {
2506 const Option &O = A->getOption();
2507 if (O.matches(options::OPT_fcolor_diagnostics)) {
2508 ShowColors = Colors_On;
2509 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2510 ShowColors = Colors_Off;
2511 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2512 StringRef
Value(A->getValue());
2513 if (
Value ==
"always")
2514 ShowColors = Colors_On;
2515 else if (
Value ==
"never")
2516 ShowColors = Colors_Off;
2517 else if (
Value ==
"auto")
2518 ShowColors = Colors_Auto;
2521 return ShowColors == Colors_On ||
2522 (ShowColors == Colors_Auto &&
2523 llvm::sys::Process::StandardErrHasColors());
2529 for (
const auto &Prefix : VerifyPrefixes) {
2532 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2535 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2537 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2538 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2548#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2549 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2550#include "clang/Driver/Options.inc"
2551#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2560#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2561 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2562#include "clang/Driver/Options.inc"
2563#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2571#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2572 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2573#include "clang/Driver/Options.inc"
2574#undef MIGRATOR_OPTION_WITH_MARSHALLING
2583#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2584 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2585#include "clang/Driver/Options.inc"
2586#undef MIGRATOR_OPTION_WITH_MARSHALLING
2591void CompilerInvocationBase::GenerateDiagnosticArgs(
2593 bool DefaultDiagColor) {
2595#define DIAG_OPTION_WITH_MARSHALLING(...) \
2596 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2597#include "clang/Driver/Options.inc"
2598#undef DIAG_OPTION_WITH_MARSHALLING
2601 GenerateArg(Consumer, OPT_diagnostic_serialized_file,
2604 if (Opts.ShowColors)
2607 if (Opts.VerifyDiagnostics &&
2612 if (Prefix !=
"expected")
2619 GenerateArg(Consumer, OPT_verify_ignore_unexpected);
2622 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"note");
2624 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"remark");
2626 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"warning");
2628 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"error");
2633 if (
Warning ==
"undef-prefix")
2636 if (
Warning ==
"invalid-constexpr" ||
Warning ==
"no-invalid-constexpr")
2638 Consumer(StringRef(
"-W") +
Warning);
2644 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2645 "pass-analysis",
"no-pass-analysis",
2646 "pass-missed",
"no-pass-missed"};
2647 if (llvm::is_contained(IgnoredRemarks,
Remark))
2650 Consumer(StringRef(
"-R") +
Remark);
2654 GenerateArg(Consumer, OPT_warning_suppression_mappings_EQ,
2659std::unique_ptr<DiagnosticOptions>
2661 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2662 unsigned MissingArgIndex, MissingArgCount;
2664 Argv.slice(1), MissingArgIndex, MissingArgCount);
2666 bool ShowColors =
true;
2667 if (std::optional<std::string> NoColor =
2668 llvm::sys::Process::GetEnv(
"NO_COLOR");
2669 NoColor && !NoColor->empty()) {
2684 bool DefaultDiagColor) {
2685 std::optional<DiagnosticOptions> IgnoringDiagOpts;
2686 std::optional<DiagnosticsEngine> IgnoringDiags;
2688 IgnoringDiagOpts.emplace();
2691 Diags = &*IgnoringDiags;
2700#define DIAG_OPTION_WITH_MARSHALLING(...) \
2701 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2702#include "clang/Driver/Options.inc"
2703#undef DIAG_OPTION_WITH_MARSHALLING
2705 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2708 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2712 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2714 if (Args.hasArg(OPT_verify))
2719 Opts.VerifyDiagnostics =
false;
2724 "-verify-ignore-unexpected=",
2725 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2726 if (Args.hasArg(OPT_verify_ignore_unexpected))
2728 Opts.setVerifyIgnoreUnexpected(DiagMask);
2730 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2735 if (
const Arg *A = Args.getLastArg(OPT_warning_suppression_mappings_EQ))
2749 std::string &BlockName,
2750 unsigned &MajorVersion,
2751 unsigned &MinorVersion,
2753 std::string &UserInfo) {
2755 Arg.split(Args,
':', 5);
2756 if (Args.size() < 5)
2759 BlockName = std::string(Args[0]);
2760 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2761 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2762 if (Args[3].getAsInteger(2, Hashed))
return true;
2763 if (Args.size() > 4)
2764 UserInfo = std::string(Args[4]);
2773 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2804 OPT_emit_reduced_module_interface},
2821 OPT_print_dependency_directives_minimized_source},
2828static std::optional<frontend::ActionKind>
2831 if (ActionOpt.second == Opt.getID())
2832 return ActionOpt.first;
2834 return std::nullopt;
2838static std::optional<OptSpecifier>
2841 if (ActionOpt.first == ProgramAction)
2842 return OptSpecifier(ActionOpt.second);
2844 return std::nullopt;
2850#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2851 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2852#include "clang/Driver/Options.inc"
2853#undef FRONTEND_OPTION_WITH_MARSHALLING
2855 std::optional<OptSpecifier> ProgramActionOpt =
2863 if (!ProgramActionOpt) {
2866 "Frontend action without option.");
2867 GenerateProgramAction = [&]() {
2874 GenerateProgramAction = [&]() {
2882 llvm_unreachable(
"Default AST dump format.");
2889 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);
2902 GenerateProgramAction = [&]() {
2907 GenerateProgramAction();
2909 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2911 for (
const auto &PluginArg : PluginArgs.second)
2913 Opt.getPrefix() + Opt.getName() + PluginArgs.first,
2914 Opt.getKind(), 0, PluginArg);
2918 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2919 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());
2925 for (
const auto &Plugin : Opts.
Plugins)
2931 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);
2944 StringRef HeaderUnit =
"";
2949 HeaderUnit =
"-user";
2952 HeaderUnit =
"-system";
2955 HeaderUnit =
"-header-unit";
2958 StringRef Header = IsHeader ?
"-header" :
"";
2981 Lang =
"objective-c";
2984 Lang =
"objective-c++";
2987 Lang =
"assembler-with-cpp";
2991 "Generating -x argument for unknown language (not precompiled).");
3006 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed);
3010 for (
const auto &Input : Opts.
Inputs)
3011 Consumer(Input.getFile());
3020#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
3021 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3022#include "clang/Driver/Options.inc"
3023#undef FRONTEND_OPTION_WITH_MARSHALLING
3026 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
3027 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
3029 assert(ProgramAction &&
"Option specifier not in Action_Group.");
3032 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
3033 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
3036 .Default(std::numeric_limits<unsigned>::max());
3038 if (Val != std::numeric_limits<unsigned>::max())
3041 Diags.
Report(diag::err_drv_invalid_value)
3042 << A->getAsString(Args) << A->getValue();
3052 Args.hasArg(OPT_interface_stub_version_EQ)
3053 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
3055 if (ArgStr ==
"experimental-yaml-elf-v1" ||
3056 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
3057 ArgStr ==
"experimental-tapi-elf-v1") {
3058 std::string ErrorMessage =
3059 "Invalid interface stub format: " + ArgStr.str() +
3061 Diags.
Report(diag::err_drv_invalid_value)
3062 <<
"Must specify a valid interface stub format type, ie: "
3063 "-interface-stub-version=ifs-v1"
3066 }
else if (!ArgStr.starts_with(
"ifs-")) {
3067 std::string ErrorMessage =
3068 "Invalid interface stub format: " + ArgStr.str() +
".";
3069 Diags.
Report(diag::err_drv_invalid_value)
3070 <<
"Must specify a valid interface stub format type, ie: "
3071 "-interface-stub-version=ifs-v1"
3086 if (!A->getSpelling().starts_with(
"-ast-dump")) {
3087 const Arg *SavedAction =
nullptr;
3088 for (
const Arg *AA :
3089 Args.filtered(OPT_Action_Group, OPT_main_file_name)) {
3090 if (AA->getOption().matches(OPT_main_file_name)) {
3091 SavedAction =
nullptr;
3092 }
else if (!SavedAction) {
3095 if (!A->getOption().matches(OPT_ast_dump_EQ))
3096 Diags.
Report(diag::err_fe_invalid_multiple_actions)
3097 << SavedAction->getSpelling() << A->getSpelling();
3104 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
3105 Opts.
Plugins.emplace_back(A->getValue(0));
3109 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
3110 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
3112 for (
const std::string &Arg :
3113 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
3114 std::string BlockName;
3115 unsigned MajorVersion;
3116 unsigned MinorVersion;
3118 std::string UserInfo;
3120 MinorVersion, Hashed, UserInfo)) {
3121 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
3128 std::make_shared<TestModuleFileExtension>(
3129 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
3132 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
3136 Diags.
Report(diag::err_drv_invalid_value)
3137 << A->getAsString(Args) << A->getValue();
3138 Diags.
Report(diag::note_command_line_code_loc_requirement);
3142 Opts.
Plugins = Args.getAllArgValues(OPT_load);
3143 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
3144 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
3146 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3147 StringRef Val = A->getValue();
3148 if (!Val.contains(
'='))
3153 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
3155 if (Args.hasArg(OPT_fclangir) || Args.hasArg(OPT_emit_cir))
3159 if (Args.hasArg(OPT_clangir_disable_passes))
3162 if (Args.hasArg(OPT_clangir_disable_verifier))
3166 if (Args.hasArg(OPT_aux_target_cpu))
3167 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
3168 if (Args.hasArg(OPT_aux_target_feature))
3172 if (
const Arg *A = Args.getLastArg(OPT_x)) {
3173 StringRef XValue = A->getValue();
3178 bool Preprocessed = XValue.consume_back(
"-cpp-output");
3179 bool ModuleMap = XValue.consume_back(
"-module-map");
3182 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
3188 if (IsHeader || Preprocessed) {
3189 if (XValue.consume_back(
"-header-unit"))
3191 else if (XValue.consume_back(
"-system"))
3193 else if (XValue.consume_back(
"-user"))
3199 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
3203 DashX = llvm::StringSwitch<InputKind>(XValue)
3219 DashX = llvm::StringSwitch<InputKind>(XValue)
3227 DashX = llvm::StringSwitch<InputKind>(XValue)
3230 .Cases(
"ast",
"pcm",
"precompiled-header",
3237 Diags.
Report(diag::err_drv_invalid_value)
3238 << A->getAsString(Args) << A->getValue();
3245 IsHeaderFile =
true;
3246 }
else if (IsHeaderFile)
3253 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
3256 Inputs.push_back(
"-");
3260 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
3262 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
3266 StringRef(Inputs[i]).rsplit(
'.').second);
3275 bool IsSystem =
false;
3284 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
3294 std::string ClangExecutable =
3295 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
3302#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3303 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3304#include "clang/Driver/Options.inc"
3305#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3314 GenerateArg(Consumer, OPT_fprebuilt_module_path, Path);
3321 std::optional<bool> IsFramework,
3322 std::optional<bool> IgnoreSysRoot) {
3323 return llvm::is_contained(Groups, Entry.
Group) &&
3324 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
3325 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
3334 OptSpecifier Opt = [It, Matches]() {
3339 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
3353 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3360 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3366 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3371 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);
3379 GenerateArg(Consumer, OPT_objc_isystem, It->Path);
3381 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);
3391 ? OPT_internal_isystem
3392 : OPT_internal_externc_isystem;
3396 GenerateArg(Consumer, OPT_internal_iframework, It->Path);
3398 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3402 OptSpecifier Opt = P.IsSystemHeader ? OPT_system_header_prefix
3403 : OPT_no_system_header_prefix;
3417#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3418 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3419#include "clang/Driver/Options.inc"
3420#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3422 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3423 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3426 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3427 StringRef Val = A->getValue();
3428 if (Val.contains(
'=')) {
3429 auto Split = Val.split(
'=');
3431 std::string(Split.first), std::string(Split.second));
3434 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3437 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3438 StringRef MacroDef = A->getValue();
3440 llvm::CachedHashString(MacroDef.split(
'=').first));
3444 bool IsSysrootSpecified =
3445 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3449 auto PrefixHeaderPath = [IsSysrootSpecified,
3450 &Opts](
const llvm::opt::Arg *A,
3451 bool IsFramework =
false) -> std::string {
3452 assert(A->getNumValues() &&
"Unexpected empty search path flag!");
3453 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3455 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3456 llvm::StringRef(A->getValue()).substr(1));
3457 return std::string(Buffer);
3459 return A->getValue();
3462 for (
const auto *A : Args.filtered(OPT_I, OPT_F)) {
3463 bool IsFramework = A->getOption().matches(OPT_F);
3469 StringRef Prefix =
"";
3470 for (
const auto *A :
3471 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3472 if (A->getOption().matches(OPT_iprefix))
3473 Prefix = A->getValue();
3474 else if (A->getOption().matches(OPT_iwithprefix))
3480 for (
const auto *A : Args.filtered(OPT_idirafter))
3482 for (
const auto *A : Args.filtered(OPT_iquote))
3485 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {
3486 if (A->getOption().matches(OPT_iwithsysroot)) {
3493 for (
const auto *A : Args.filtered(OPT_iframework))
3495 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3500 for (
const auto *A : Args.filtered(OPT_c_isystem))
3502 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3504 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3506 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3510 for (
const auto *A :
3511 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3513 if (A->getOption().matches(OPT_internal_externc_isystem))
3515 Opts.
AddPath(A->getValue(), Group,
false,
true);
3517 for (
const auto *A : Args.filtered(OPT_internal_iframework))
3521 for (
const auto *A :
3522 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3524 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3526 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3535 GenerateArg(Consumer, OPT_fapinotes_swift_version,
3539 GenerateArg(Consumer, OPT_iapinotes_modules, Path);
3544 if (
const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {
3546 diags.
Report(diag::err_drv_invalid_value)
3547 << A->getAsString(Args) << A->getValue();
3549 for (
const Arg *A : Args.filtered(OPT_iapinotes_modules))
3555 if (Opts.PointerAuthIntrinsics)
3557 if (Opts.PointerAuthCalls)
3559 if (Opts.PointerAuthReturns)
3561 if (Opts.PointerAuthIndirectGotos)
3562 GenerateArg(Consumer, OPT_fptrauth_indirect_gotos);
3563 if (Opts.PointerAuthAuthTraps)
3565 if (Opts.PointerAuthVTPtrAddressDiscrimination)
3566 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_address_discrimination);
3567 if (Opts.PointerAuthVTPtrTypeDiscrimination)
3568 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_type_discrimination);
3569 if (Opts.PointerAuthTypeInfoVTPtrDiscrimination)
3570 GenerateArg(Consumer, OPT_fptrauth_type_info_vtable_pointer_discrimination);
3571 if (Opts.PointerAuthFunctionTypeDiscrimination)
3572 GenerateArg(Consumer, OPT_fptrauth_function_pointer_type_discrimination);
3573 if (Opts.PointerAuthInitFini)
3575 if (Opts.PointerAuthInitFiniAddressDiscrimination)
3576 GenerateArg(Consumer, OPT_fptrauth_init_fini_address_discrimination);
3577 if (Opts.PointerAuthELFGOT)
3579 if (Opts.AArch64JumpTableHardening)
3580 GenerateArg(Consumer, OPT_faarch64_jump_table_hardening);
3581 if (Opts.PointerAuthObjcIsa)
3583 if (Opts.PointerAuthObjcInterfaceSel)
3584 GenerateArg(Consumer, OPT_fptrauth_objc_interface_sel);
3585 if (Opts.PointerAuthObjcClassROPointers)
3586 GenerateArg(Consumer, OPT_fptrauth_objc_class_ro);
3587 if (Opts.PointerAuthBlockDescriptorPointers)
3588 GenerateArg(Consumer, OPT_fptrauth_block_descriptor_pointers);
3593 Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);
3594 Opts.PointerAuthCalls = Args.hasArg(OPT_fptrauth_calls);
3595 Opts.PointerAuthReturns = Args.hasArg(OPT_fptrauth_returns);
3596 Opts.PointerAuthIndirectGotos = Args.hasArg(OPT_fptrauth_indirect_gotos);
3597 Opts.PointerAuthAuthTraps = Args.hasArg(OPT_fptrauth_auth_traps);
3598 Opts.PointerAuthVTPtrAddressDiscrimination =
3599 Args.hasArg(OPT_fptrauth_vtable_pointer_address_discrimination);
3600 Opts.PointerAuthVTPtrTypeDiscrimination =
3601 Args.hasArg(OPT_fptrauth_vtable_pointer_type_discrimination);
3602 Opts.PointerAuthTypeInfoVTPtrDiscrimination =
3603 Args.hasArg(OPT_fptrauth_type_info_vtable_pointer_discrimination);
3604 Opts.PointerAuthFunctionTypeDiscrimination =
3605 Args.hasArg(OPT_fptrauth_function_pointer_type_discrimination);
3606 Opts.PointerAuthInitFini = Args.hasArg(OPT_fptrauth_init_fini);
3607 Opts.PointerAuthInitFiniAddressDiscrimination =
3608 Args.hasArg(OPT_fptrauth_init_fini_address_discrimination);
3609 Opts.PointerAuthELFGOT = Args.hasArg(OPT_fptrauth_elf_got);
3610 Opts.AArch64JumpTableHardening =
3611 Args.hasArg(OPT_faarch64_jump_table_hardening);
3612 Opts.PointerAuthBlockDescriptorPointers =
3613 Args.hasArg(OPT_fptrauth_block_descriptor_pointers);
3614 Opts.PointerAuthObjcIsa = Args.hasArg(OPT_fptrauth_objc_isa);
3615 Opts.PointerAuthObjcClassROPointers = Args.hasArg(OPT_fptrauth_objc_class_ro);
3616 Opts.PointerAuthObjcInterfaceSel =
3617 Args.hasArg(OPT_fptrauth_objc_interface_sel);
3619 if (Opts.PointerAuthObjcInterfaceSel)
3620 Opts.PointerAuthObjcInterfaceSelKey =
3631 llvm_unreachable(
"should not parse language flags for this input");
3666 llvm_unreachable(
"unexpected input language");
3675 return "Objective-C";
3679 return "Objective-C++";
3683 return "C++ for OpenCL";
3702 llvm_unreachable(
"unknown input language");
3705void CompilerInvocationBase::GenerateLangArgs(
const LangOptions &Opts,
3707 const llvm::Triple &
T,
3712 if (Opts.ObjCAutoRefCount)
3714 if (Opts.PICLevel != 0)
3715 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));
3719 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3724 OptSpecifier StdOpt;
3726 case LangStandard::lang_opencl10:
3727 case LangStandard::lang_opencl11:
3728 case LangStandard::lang_opencl12:
3729 case LangStandard::lang_opencl20:
3730 case LangStandard::lang_opencl30:
3731 case LangStandard::lang_openclcpp10:
3732 case LangStandard::lang_openclcpp2021:
3733 StdOpt = OPT_cl_std_EQ;
3736 StdOpt = OPT_std_EQ;
3741 GenerateArg(Consumer, StdOpt, LangStandard.getName());
3743 if (Opts.IncludeDefaultHeader)
3744 GenerateArg(Consumer, OPT_finclude_default_header);
3745 if (Opts.DeclareOpenCLBuiltins)
3746 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);
3748 const LangOptions *
LangOpts = &Opts;
3750#define LANG_OPTION_WITH_MARSHALLING(...) \
3751 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3752#include "clang/Driver/Options.inc"
3753#undef LANG_OPTION_WITH_MARSHALLING
3764 else if (Opts.ObjCAutoRefCount == 1)
3767 if (Opts.ObjCWeakRuntime)
3768 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);
3773 if (Opts.ObjCSubscriptingLegacyRuntime)
3774 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);
3777 if (Opts.GNUCVersion != 0) {
3778 unsigned Major = Opts.GNUCVersion / 100 / 100;
3779 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3780 unsigned Patch = Opts.GNUCVersion % 100;
3782 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch));
3785 if (Opts.IgnoreXCOFFVisibility)
3786 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);
3794 if (Opts.PointerOverflowDefined)
3797 if (Opts.MSCompatibilityVersion != 0) {
3798 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3799 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3800 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3801 GenerateArg(Consumer, OPT_fms_compatibility_version,
3802 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor));
3805 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3807 if (!Opts.Trigraphs)
3814 if (
T.isOSzOS() && !Opts.ZOSExt)
3816 else if (Opts.ZOSExt)
3819 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3822 if (Opts.ConvergentFunctions)
3825 GenerateArg(Consumer, OPT_fno_convergent_functions);
3827 if (Opts.NoBuiltin && !Opts.Freestanding)
3830 if (!Opts.NoBuiltin)
3834 if (Opts.LongDoubleSize == 128)
3836 else if (Opts.LongDoubleSize == 64)
3838 else if (Opts.LongDoubleSize == 80)
3845 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3848 if (Opts.OpenMP != 51)
3849 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3851 if (!Opts.OpenMPUseTLS)
3854 if (Opts.OpenMPIsTargetDevice)
3855 GenerateArg(Consumer, OPT_fopenmp_is_target_device);
3857 if (Opts.OpenMPIRBuilder)
3858 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);
3861 if (Opts.OpenMPSimd) {
3864 if (Opts.OpenMP != 51)
3865 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3868 if (Opts.OpenMPThreadSubscription)
3869 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);
3871 if (Opts.OpenMPTeamSubscription)
3872 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);
3874 if (Opts.OpenMPTargetDebug != 0)
3875 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,
3876 Twine(Opts.OpenMPTargetDebug));
3878 if (Opts.OpenMPCUDANumSMs != 0)
3879 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,
3880 Twine(Opts.OpenMPCUDANumSMs));
3882 if (Opts.OpenMPCUDABlocksPerSM != 0)
3883 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3884 Twine(Opts.OpenMPCUDABlocksPerSM));
3886 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3887 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3888 Twine(Opts.OpenMPCUDAReductionBufNum));
3891 std::string Targets;
3892 llvm::raw_string_ostream
OS(Targets);
3895 [&OS](
const llvm::Triple &
T) { OS << T.str(); },
",");
3896 GenerateArg(Consumer, OPT_offload_targets_EQ, Targets);
3899 if (Opts.OpenMPCUDAMode)
3915 GenerateArg(Consumer, OPT_ffp_contract,
"fast-honor-pragmas");
3918 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3922 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
3924 switch (Opts.getClangABICompat()) {
3925#define ABI_VER_MAJOR_MINOR(Major, Minor) \
3926 case LangOptions::ClangABI::Ver##Major##_##Minor: \
3927 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, #Major "." #Minor); \
3929#define ABI_VER_MAJOR(Major) \
3930 case LangOptions::ClangABI::Ver##Major: \
3931 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, #Major ".0"); \
3933#define ABI_VER_LATEST(Latest) \
3934 case LangOptions::ClangABI::Latest: \
3936#include "clang/Basic/ABIVersions.def"
3939 if (Opts.getSignReturnAddressScope() ==
3941 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"all");
3942 else if (Opts.getSignReturnAddressScope() ==
3944 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"non-leaf");
3946 if (Opts.getSignReturnAddressKey() ==
3948 GenerateArg(Consumer, OPT_msign_return_address_key_EQ,
"b_key");
3954 if (Opts.RelativeCXXABIVTables)
3955 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);
3957 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);
3965 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second);
3971bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3973 std::vector<std::string> &Includes,
3983 if (Args.hasArg(OPT_fobjc_arc))
3984 Opts.ObjCAutoRefCount = 1;
3988 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
4000 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
4003 Diags.
Report(diag::err_drv_invalid_value)
4004 << A->getAsString(Args) << A->getValue();
4006 for (
unsigned KindValue = 0;
4012 auto Diag = Diags.
Report(diag::note_drv_use_standard);
4014 unsigned NumAliases = 0;
4015#define LANGSTANDARD(id, name, lang, desc, features, version)
4016#define LANGSTANDARD_ALIAS(id, alias) \
4017 if (KindValue == LangStandard::lang_##id) ++NumAliases;
4018#define LANGSTANDARD_ALIAS_DEPR(id, alias)
4019#include "clang/Basic/LangStandards.def"
4021#define LANGSTANDARD(id, name, lang, desc, features, version)
4022#define LANGSTANDARD_ALIAS(id, alias) \
4023 if (KindValue == LangStandard::lang_##id) Diag << alias;
4024#define LANGSTANDARD_ALIAS_DEPR(id, alias)
4025#include "clang/Basic/LangStandards.def"
4033 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4041 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
4043 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
4044 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
4045 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
4046 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
4047 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
4048 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
4049 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
4050 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
4051 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
4052 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
4056 Diags.
Report(diag::err_drv_invalid_value)
4057 << A->getAsString(Args) << A->getValue();
4060 LangStd = OpenCLLangStd;
4064 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
4065 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
4073#define LANG_OPTION_WITH_MARSHALLING(...) \
4074 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4075#include "clang/Driver/Options.inc"
4076#undef LANG_OPTION_WITH_MARSHALLING
4078 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4079 StringRef Name = A->getValue();
4080 if (Name ==
"full") {
4081 Opts.CFProtectionBranch = 1;
4082 Opts.CFProtectionReturn = 1;
4083 }
else if (Name ==
"branch") {
4084 Opts.CFProtectionBranch = 1;
4085 }
else if (Name ==
"return") {
4086 Opts.CFProtectionReturn = 1;
4090 if (Opts.CFProtectionBranch) {
4091 if (
const Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {
4093 llvm::StringSwitch<CFBranchLabelSchemeKind>(A->getValue())
4094#define CF_BRANCH_LABEL_SCHEME(Kind, FlagVal) \
4095 .Case(#FlagVal, CFBranchLabelSchemeKind::Kind)
4096#include "clang/Basic/CFProtectionOptions.def"
4098 Opts.setCFBranchLabelScheme(Scheme);
4102 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
4103 !Args.hasArg(OPT_sycl_std_EQ)) {
4113 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
4114 StringRef value =
arg->getValue();
4116 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
4119 if (Args.hasArg(OPT_fobjc_gc_only))
4121 else if (Args.hasArg(OPT_fobjc_gc))
4123 else if (Args.hasArg(OPT_fobjc_arc)) {
4124 Opts.ObjCAutoRefCount = 1;
4126 Diags.
Report(diag::err_arc_unsupported_on_runtime);
4133 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
4134 Opts.ObjCWeakRuntime = 1;
4140 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
4141 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
4142 assert(!Opts.ObjCWeak);
4144 Diags.
Report(diag::err_objc_weak_with_gc);
4145 }
else if (!Opts.ObjCWeakRuntime) {
4146 Diags.
Report(diag::err_objc_weak_unsupported);
4150 }
else if (Opts.ObjCAutoRefCount) {
4151 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
4154 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
4155 Opts.ObjCSubscriptingLegacyRuntime =
4159 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
4162 VersionTuple GNUCVer;
4163 bool Invalid = GNUCVer.tryParse(A->getValue());
4164 unsigned Major = GNUCVer.getMajor();
4165 unsigned Minor = GNUCVer.getMinor().value_or(0);
4166 unsigned Patch = GNUCVer.getSubminor().value_or(0);
4167 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
4168 Diags.
Report(diag::err_drv_invalid_value)
4169 << A->getAsString(Args) << A->getValue();
4171 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
4174 if (
T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
4175 Opts.IgnoreXCOFFVisibility = 1;
4177 if (Args.hasArg(OPT_ftrapv)) {
4181 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
4183 else if (Args.hasArg(OPT_fwrapv))
4185 if (Args.hasArg(OPT_fwrapv_pointer))
4186 Opts.PointerOverflowDefined =
true;
4188 Opts.MSCompatibilityVersion = 0;
4189 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
4191 if (VT.tryParse(A->getValue()))
4192 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
4194 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
4195 VT.getMinor().value_or(0) * 100000 +
4196 VT.getSubminor().value_or(0);
4204 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
4207 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
4210 Args.hasFlag(OPT_fzos_extensions, OPT_fno_zos_extensions,
T.isOSzOS());
4212 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
4213 && Opts.OpenCLVersion == 200);
4215 bool HasConvergentOperations = Opts.
isTargetDevice() || Opts.OpenCL ||
4216 Opts.HLSL ||
T.isAMDGPU() ||
T.isNVPTX();
4217 Opts.ConvergentFunctions =
4218 Args.hasFlag(OPT_fconvergent_functions, OPT_fno_convergent_functions,
4219 HasConvergentOperations);
4221 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
4222 if (!Opts.NoBuiltin)
4224 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
4225 if (A->getOption().matches(options::OPT_mlong_double_64))
4226 Opts.LongDoubleSize = 64;
4227 else if (A->getOption().matches(options::OPT_mlong_double_80))
4228 Opts.LongDoubleSize = 80;
4229 else if (A->getOption().matches(options::OPT_mlong_double_128))
4230 Opts.LongDoubleSize = 128;
4232 Opts.LongDoubleSize = 0;
4234 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
4240 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
4242 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4243 << A->getSpelling() <<
"-fdefault-calling-conv";
4245 switch (
T.getArch()) {
4246 case llvm::Triple::x86:
4249 case llvm::Triple::m68k:
4253 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4254 << A->getSpelling() <<
T.getTriple();
4260 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;
4262 bool IsSimdSpecified =
4263 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
4265 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
4267 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
4268 Opts.OpenMPIsTargetDevice =
4269 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);
4270 Opts.OpenMPIRBuilder =
4271 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
4272 bool IsTargetSpecified =
4273 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_offload_targets_EQ);
4275 if (Opts.OpenMP || Opts.OpenMPSimd) {
4277 Args, OPT_fopenmp_version_EQ,
4278 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))
4279 Opts.OpenMP = Version;
4282 if (!Opts.OpenMPIsTargetDevice) {
4283 switch (
T.getArch()) {
4287 case llvm::Triple::nvptx:
4288 case llvm::Triple::nvptx64:
4289 Diags.
Report(diag::err_drv_omp_host_target_not_supported) <<
T.str();
4297 if ((Opts.OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN())) ||
4298 Opts.OpenCLCPlusPlus) {
4300 Opts.Exceptions = 0;
4301 Opts.CXXExceptions = 0;
4303 if (Opts.OpenMPIsTargetDevice &&
T.isNVPTX()) {
4304 Opts.OpenMPCUDANumSMs =
4306 Opts.OpenMPCUDANumSMs, Diags);
4307 Opts.OpenMPCUDABlocksPerSM =
4309 Opts.OpenMPCUDABlocksPerSM, Diags);
4311 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
4312 Opts.OpenMPCUDAReductionBufNum, Diags);
4317 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
4318 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
4320 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
4321 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
4322 Opts.OpenMPTargetDebug = 1;
4325 if (Opts.OpenMPIsTargetDevice) {
4326 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
4327 Opts.OpenMPTeamSubscription =
true;
4328 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
4329 Opts.OpenMPThreadSubscription =
true;
4333 if (Arg *A = Args.getLastArg(options::OPT_offload_targets_EQ)) {
4334 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
4335 auto getArchPtrSize = [](
const llvm::Triple &
T) {
4336 if (
T.isArch16Bit())
4338 if (
T.isArch32Bit())
4340 assert(
T.isArch64Bit() &&
"Expected 64-bit architecture");
4344 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
4345 llvm::Triple TT(A->getValue(i));
4347 if (TT.getArch() == llvm::Triple::UnknownArch ||
4348 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
4349 TT.getArch() == llvm::Triple::spirv64 ||
4350 TT.getArch() == llvm::Triple::systemz ||
4351 TT.getArch() == llvm::Triple::loongarch64 ||
4352 TT.getArch() == llvm::Triple::nvptx ||
4353 TT.getArch() == llvm::Triple::nvptx64 || TT.isAMDGCN() ||
4354 TT.getArch() == llvm::Triple::x86 ||
4355 TT.getArch() == llvm::Triple::x86_64))
4356 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
4357 else if (getArchPtrSize(
T) != getArchPtrSize(TT))
4358 Diags.
Report(diag::err_drv_incompatible_omp_arch)
4359 << A->getValue(i) <<
T.str();
4366 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&
4367 (
T.isNVPTX() ||
T.isAMDGCN()) &&
4368 Args.hasArg(options::OPT_fopenmp_cuda_mode);
4371 if (Args.hasArg(options::OPT_fopenacc))
4372 Opts.OpenACC =
true;
4374 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
4375 StringRef Val = A->getValue();
4378 else if (Val ==
"on")
4380 else if (Val ==
"off")
4382 else if (Val ==
"fast-honor-pragmas")
4385 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
4389 Args.getLastArg(OPT_fsanitize_undefined_ignore_overflow_pattern_EQ)) {
4390 for (
int i = 0, n = A->getNumValues(); i != n; ++i) {
4392 llvm::StringSwitch<unsigned>(A->getValue(i))
4395 .Case(
"add-unsigned-overflow-test",
4397 .Case(
"add-signed-overflow-test",
4400 .Case(
"unsigned-post-decr-while",
4409 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
4410 std::vector<std::string> systemIgnorelists =
4411 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
4413 systemIgnorelists.begin(),
4414 systemIgnorelists.end());
4416 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
4417 Opts.setClangABICompat(LangOptions::ClangABI::Latest);
4419 StringRef Ver = A->getValue();
4420 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
4421 int Major, Minor = 0;
4425 if (!VerParts.first.starts_with(
"0") &&
4426 !VerParts.first.getAsInteger(10, Major) && 3 <= Major &&
4427 Major <= MAX_CLANG_ABI_COMPAT_VERSION &&
4429 ? VerParts.second.size() == 1 &&
4430 !VerParts.second.getAsInteger(10, Minor)
4431 : VerParts.first.size() == Ver.size() || VerParts.second ==
"0")) {
4433#define ABI_VER_MAJOR_MINOR(Major_, Minor_) \
4434 if (std::tuple(Major, Minor) <= std::tuple(Major_, Minor_)) \
4435 Opts.setClangABICompat(LangOptions::ClangABI::Ver##Major_##_##Minor_); \
4437#define ABI_VER_MAJOR(Major_) \
4438 if (Major <= Major_) \
4439 Opts.setClangABICompat(LangOptions::ClangABI::Ver##Major_); \
4441#define ABI_VER_LATEST(Latest) \
4444#include "clang/Basic/ABIVersions.def"
4445 }
else if (Ver !=
"latest") {
4446 Diags.
Report(diag::err_drv_invalid_value)
4447 << A->getAsString(Args) << A->getValue();
4451 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4452 StringRef SignScope = A->getValue();
4454 if (SignScope.equals_insensitive(
"none"))
4455 Opts.setSignReturnAddressScope(
4457 else if (SignScope.equals_insensitive(
"all"))
4458 Opts.setSignReturnAddressScope(
4460 else if (SignScope.equals_insensitive(
"non-leaf"))
4461 Opts.setSignReturnAddressScope(
4464 Diags.
Report(diag::err_drv_invalid_value)
4465 << A->getAsString(Args) << SignScope;
4467 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4468 StringRef SignKey = A->getValue();
4469 if (!SignScope.empty() && !SignKey.empty()) {
4470 if (SignKey ==
"a_key")
4471 Opts.setSignReturnAddressKey(
4473 else if (SignKey ==
"b_key")
4474 Opts.setSignReturnAddressKey(
4477 Diags.
Report(diag::err_drv_invalid_value)
4478 << A->getAsString(Args) << SignKey;
4484 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4491 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI <<
T.str();
4497 Opts.RelativeCXXABIVTables =
4498 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4499 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4503 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);
4504 Opts.OmitVTableRTTI =
4505 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
4506 options::OPT_fno_experimental_omit_vtable_rtti,
false);
4507 if (Opts.OmitVTableRTTI && HasRTTI)
4508 Diags.
Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
4510 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4511 auto Split = StringRef(A).split(
'=');
4513 {std::string(
Split.first), std::string(
Split.second)});
4517 !Args.getLastArg(OPT_fno_file_reproducible) &&
4518 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4519 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4520 Args.getLastArg(OPT_ffile_reproducible));
4523 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4525 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4526 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4528 if (Arg *A = Args.getLastArg(options::OPT_mvscale_streaming_min_EQ)) {
4530 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4531 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4534 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4535 std::ifstream SeedFile(A->getValue(0));
4537 if (!SeedFile.is_open())
4538 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4544 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4551 if (
T.isDXIL() ||
T.isSPIRVLogical()) {
4553 enum {
OS, Environment };
4555 int ExpectedOS =
T.isSPIRVLogical() ? VulkanEnv : ShaderModel;
4557 if (
T.getOSName().empty()) {
4558 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4559 << ExpectedOS <<
OS <<
T.str();
4560 }
else if (
T.getEnvironmentName().empty()) {
4561 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4563 }
else if (!
T.isShaderStageEnvironment()) {
4564 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4569 if (!
T.isShaderModelOS() ||
T.getOSVersion() == VersionTuple(0)) {
4570 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4571 << ShaderModel <<
T.getOSName() <<
T.str();
4576 if (Args.getLastArg(OPT_fnative_half_type)) {
4577 const LangStandard &Std =
4579 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018 &&
4580 T.getOSVersion() >= VersionTuple(6, 2)))
4581 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4582 <<
"-enable-16bit-types" <<
true << Std.
getName()
4583 <<
T.getOSVersion().getAsString();
4585 }
else if (
T.isSPIRVLogical()) {
4586 if (!
T.isVulkanOS() ||
T.getVulkanVersion() == VersionTuple(0)) {
4587 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4588 << VulkanEnv <<
T.getOSName() <<
T.str();
4590 if (Args.getLastArg(OPT_fnative_half_type)) {
4591 const LangStandard &Std =
4593 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018))
4594 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4595 <<
"-fnative-half-type" <<
false << Std.
getName();
4598 llvm_unreachable(
"expected DXIL or SPIR-V target");
4601 Diags.
Report(diag::err_drv_hlsl_unsupported_target) <<
T.str();
4603 if (Opts.
LangStd < LangStandard::lang_hlsl202x) {
4604 const LangStandard &Requested =
4606 const LangStandard &Recommended =
4608 Diags.
Report(diag::warn_hlsl_langstd_minimal)
4659 llvm_unreachable(
"invalid frontend action");
4704 llvm_unreachable(
"invalid frontend action");
4714#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4715 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4716#include "clang/Driver/Options.inc"
4717#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4720 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);
4723 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl, D);
4730 for (
const auto &M : Opts.
Macros) {
4733 if (M.first ==
"__CET__=1" && !M.second &&
4734 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4736 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4737 !CodeGenOpts.CFProtectionBranch)
4739 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4740 CodeGenOpts.CFProtectionBranch)
4743 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);
4746 for (
const auto &I : Opts.
Includes) {
4749 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4750 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4755 if (LangOpts.HLSL && I ==
"hlsl.h")
4765 GenerateArg(Consumer, OPT_remap_file, RF.first +
";" + RF.second);
4771 GenerateArg(Consumer, OPT_fdefine_target_os_macros);
4774 GenerateArg(Consumer, OPT_embed_dir_EQ, EmbedEntry);
4788#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4789 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4790#include "clang/Driver/Options.inc"
4791#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4793 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4794 Args.hasArg(OPT_pch_through_hdrstop_use);
4796 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4799 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4800 StringRef
Value(A->getValue());
4801 size_t Comma =
Value.find(
',');
4803 unsigned EndOfLine = 0;
4805 if (Comma == StringRef::npos ||
4806 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4807 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4808 Diags.
Report(diag::err_drv_preamble_format);
4816 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4817 if (A->getOption().matches(OPT_D))
4824 for (
const auto *A : Args.filtered(OPT_include))
4825 Opts.
Includes.emplace_back(A->getValue());
4827 for (
const auto *A : Args.filtered(OPT_chain_include))
4830 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4831 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4833 if (Split.second.empty()) {
4834 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4841 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4842 StringRef Epoch = A->getValue();
4846 const uint64_t MaxTimestamp =
4847 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4849 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4850 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4851 << Epoch << MaxTimestamp;
4857 for (
const auto *A : Args.filtered(OPT_embed_dir_EQ)) {
4858 StringRef Val = A->getValue();
4869 Args.hasFlag(OPT_fdefine_target_os_macros,
4881#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4882 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4883#include "clang/Driver/Options.inc"
4884#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4902#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4903 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4904#include "clang/Driver/Options.inc"
4905#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4908 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4917#define TARGET_OPTION_WITH_MARSHALLING(...) \
4918 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4919#include "clang/Driver/Options.inc"
4920#undef TARGET_OPTION_WITH_MARSHALLING
4926 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,
4936#define TARGET_OPTION_WITH_MARSHALLING(...) \
4937 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4938#include "clang/Driver/Options.inc"
4939#undef TARGET_OPTION_WITH_MARSHALLING
4941 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4942 llvm::VersionTuple Version;
4943 if (Version.tryParse(A->getValue()))
4944 Diags.
Report(diag::err_drv_invalid_value)
4945 << A->getAsString(Args) << A->getValue();
4950 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4951 llvm::VersionTuple Version;
4952 if (Version.tryParse(A->getValue()))
4953 Diags.
Report(diag::err_drv_invalid_value)
4954 << A->getAsString(Args) << A->getValue();
4962bool CompilerInvocation::CreateFromArgsImpl(
4970 unsigned MissingArgIndex, MissingArgCount;
4971 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4972 MissingArgCount, VisibilityMask);
4976 if (MissingArgCount)
4977 Diags.
Report(diag::err_drv_missing_argument)
4978 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4981 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4982 auto ArgString = A->getAsString(Args);
4983 std::string Nearest;
4984 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)
4985 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4987 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4988 << ArgString << Nearest;
5021 !Diags.
isIgnored(diag::warn_profile_data_misexpect, SourceLocation())) {
5035 Diags.
Report(diag::warn_drv_openacc_without_cir);
5048 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
5049 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
5050 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
5051 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
5064 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
5070 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
5081 llvm::driver::ProfileInstrKind::ProfileNone)
5082 Diags.
Report(diag::err_drv_profile_instrument_use_path_with_no_kind);
5092 const char *Argv0) {
5098 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
5102 Args.push_back(
"-cc1");
5105 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
5110 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;
5125#define LANGOPT(Name, Bits, Default, Compatibility, Description) \
5126 if constexpr (CK::Compatibility != CK::Benign) \
5127 HBuilder.add(LangOpts->Name);
5128#define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
5129 if constexpr (CK::Compatibility != CK::Benign) \
5130 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
5131#include "clang/Basic/LangOptions.def"
5136 HBuilder.addRange(
getLangOpts().CommentOpts.BlockCommandNames);
5153 StringRef MacroDef =
Macro.first;
5155 llvm::CachedHashString(MacroDef.split(
'=').first)))
5159 HBuilder.add(
Macro);
5175#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
5176#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5177 HBuilder.add(diagOpts.get##Name());
5178#include "clang/Basic/DiagnosticOptions.def"
5188 ext->hashExtension(HBuilder);
5195 HBuilder.add(*Minor);
5196 if (
auto Subminor =
APINotesOpts.SwiftVersion.getSubminor())
5197 HBuilder.add(*Subminor);
5199 HBuilder.add(*Build);
5205#define CODEGENOPT(Name, Bits, Default, Compatibility) \
5206 if constexpr (CK::Compatibility != CK::Benign) \
5207 HBuilder.add(CodeGenOpts->Name);
5208#define ENUM_CODEGENOPT(Name, Type, Bits, Default, Compatibility) \
5209 if constexpr (CK::Compatibility != CK::Benign) \
5210 HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
5211#define DEBUGOPT(Name, Bits, Default, Compatibility)
5212#define VALUE_DEBUGOPT(Name, Bits, Default, Compatibility)
5213#define ENUM_DEBUGOPT(Name, Type, Bits, Default, Compatibility)
5214#include "clang/Basic/CodeGenOptions.def"
5226#define DEBUGOPT(Name, Bits, Default, Compatibility) \
5227 if constexpr (CK::Compatibility != CK::Benign) \
5228 HBuilder.add(CodeGenOpts->Name);
5229#define VALUE_DEBUGOPT(Name, Bits, Default, Compatibility) \
5230 if constexpr (CK::Compatibility != CK::Benign) \
5231 HBuilder.add(CodeGenOpts->Name);
5232#define ENUM_DEBUGOPT(Name, Type, Bits, Default, Compatibility) \
5233 if constexpr (CK::Compatibility != CK::Benign) \
5234 HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
5235#include "clang/Basic/DebugOptions.def"
5242 if (!SanHash.
empty())
5243 HBuilder.add(SanHash.
Mask);
5245 llvm::MD5::MD5Result
Result;
5246 HBuilder.getHasher().final(
Result);
5248 return toString(llvm::APInt(64, Hash), 36,
false);
5276 std::vector<std::string> Args{
"-cc1"};
5278 [&Args](
const Twine &Arg) { Args.push_back(Arg.str()); });
5304 llvm::vfs::getRealFileSystem());
5312 Diags, std::move(BaseFS));
5318 if (VFSOverlayFiles.empty())
5323 for (
const auto &
File : VFSOverlayFiles) {
5324 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
5327 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
5332 std::move(Buffer.get()),
nullptr,
File,
5335 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)
T & ensureOwned(std::shared_ptr< T > &Storage)
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 bool isCodeGenAction(frontend::ActionKind Action)
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 llvm::StringRef lookupStrInTable(unsigned Offset)
static void GeneratePreprocessorArgs(const PreprocessorOptions &Opts, ArgumentConsumer Consumer, const LangOptions &LangOpts, const FrontendOptions &FrontendOpts, const CodeGenOptions &CodeGenOpts)
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)
llvm::function_ref< void( CompilerInvocation &, SmallVectorImpl< const char * > &, CompilerInvocation::StringAllocator)> GenerateFn
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)
std::shared_ptr< T > make_shared_copy(const T &X)
llvm::function_ref< bool(CompilerInvocation &, ArrayRef< const char * >, DiagnosticsEngine &, const char *)> ParseFn
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 bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
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.
#define CXXABI(Name, Str)
Defines the clang::TargetOptions class.
Defines version macros and version-related utility functions for Clang.
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.
CompatibilityKind
For ASTs produced with different option value, signifies their level of compatibility.
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.
std::optional< uint64_t > AllocTokenMax
Maximum number of allocation tokens (0 = no max), nullopt if none set (use pass default).
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
bool hasSanitizeCoverage() const
SanitizerSet SanitizeAnnotateDebugInfo
Set of sanitizer checks, for which the instrumentation will be annotated with extra debug info.
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::optional< double > AllowRuntimeCheckSkipHotCutoff
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< DiagnosticOptions > DiagnosticOpts
Options controlling the diagnostic engine.
std::shared_ptr< AnalyzerOptions > AnalyzerOpts
Options controlling the static analyzer.
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
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()
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.
static llvm::IntrusiveRefCntPtr< DiagnosticIDs > create()
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.
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.
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.
unsigned ClangIRDisablePasses
Disable Clang IR specific (CIR) passes.
std::map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
unsigned ClangIRDisableCIRVerifier
Disable Clang IR (CIR) verifier.
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.
unsigned GenReducedBMI
Whether to generate reduced BMI for C++20 named modules.
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.
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–)
CompatibilityKind
For ASTs produced with different option value, signifies their level of compatibility.
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 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().
bool isTargetDevice() const
True when compiling for an offloading target device.
LangStandard::Kind LangStd
The used language standard.
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 separ...
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 beginnin...
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()
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
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.
@ 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.
bool EQ(InterpState &S, CodePtr OpPC)
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.
bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args, DiagnosticsEngine *Diags=nullptr, bool DefaultDiagColor=true)
Fill out Opts based on the options given in Args.
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.
const char * headerIncludeFormatKindToString(HeaderIncludeFormatKind K)
std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)
constexpr uint16_t BlockDescriptorConstantDiscriminator
Constant discriminator to be used with block descriptor pointers.
constexpr uint16_t IsaPointerConstantDiscriminator
Constant discriminator to be used with objective-c isa pointers.
const char * headerIncludeFilteringKindToString(HeaderIncludeFilteringKind K)
std::vector< std::string > Macros
A list of macros of the form <definition>=<expansion> .
AnalysisConstraints
AnalysisConstraints - Set of available constraint models.
@ Success
Annotation was successful.
@ Parse
Parse the block; this code is always used.
constexpr uint16_t SuperPointerConstantDiscriminator
Constant discriminator to be used with objective-c superclass pointers.
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 MethodListPointerConstantDiscriminator
Constant discriminator to be used with method list pointers.
constexpr uint16_t ClassROConstantDiscriminator
Constant discriminator to be used with objective-c class_ro_t pointers.
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.
const FunctionProtoType * T
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 command line arguments.
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.
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.
AnalysisInliningMode
AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
int const char * function
__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.
clang::Language getLanguage() const
Get the language that this standard describes.
const char * getDescription() const
getDescription - Get the description of this 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 BlockDescriptorPointers
The ABI for pointers to block descriptors.
PointerAuthSchema BlockHelperFunctionPointers
The ABI for block object copy/destroy function pointers.
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 BlockInvocationFunctionPointers
The ABI for block invocation function pointers.
PointerAuthSchema BlockByrefHelperFunctionPointers
The ABI for __block variable copy/destroy function pointers.
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 ObjCMethodListPointer
The ABI for a reference to an Objective-C method list in _class_ro_t.
PointerAuthSchema FunctionPointers
The ABI for C function pointers.
PointerAuthSchema ObjCSuperPointers
The ABI for Objective-C superclass 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 ObjCMethodListFunctionPointers
The ABI for Objective-C method lists.
PointerAuthSchema ObjCClassROPointers
The ABI for Objective-C class_ro_t pointers.
PointerAuthSchema CXXVirtualFunctionPointers
The ABI for most C++ virtual function pointers, i.e. v-table entries.
PointerAuthSchema ObjCIsaPointers
The ABI for Objective-C isa pointers.
bool IndirectGotos
Do indirect goto label addresses need to be authenticated?
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
bool empty() const
Returns true if no sanitizers are enabled.
SanitizerMask Mask
Bitmask of enabled sanitizers.
void set(XRayInstrMask K, bool Value)